Criando projetos Java com Gradle

Nesse artigo iremos usar o Gradle para criar um projeto Java simples. Precisaremos de aproximadamente 15 minutos, seu editor de texto ou IDE favorito e o Jdk 6 ou mais recente.

Como completar esse tutorial

Como a maioria dos tutoriais Spring, você pode começar do zero e completar cada etapa ou pode pular os passos mais básicos com os quais você já esteja familiarizado. De qualquer maneira, você terminará com um código funcional.
Para começar do zero, vá pra a seção Configure o seu projeto.
Para pular as etapas mais básicas, execute os seguintes comandos:

Baixe e descompacte o código fonte desse artigo, ou clone o repositório usando o Git:
```
git clone https://github.com/spring-guides/gs-gradle.git
```
vá para o diretório gs-gradle/initial
Pule para a seção Instalação do Gradle

Quando você terminar, pode verificar o resultado com o código em gs-gradle/complete.

Configure o seu projeto

Para começar, você deve criar um projeto Java para ser compilado pelo Gradle. Para que possamos focar no Gradle, iremos utilizar o projeto mais simples possível.

Crie a estrutura de diretórios

Em um diretório de projeto de sua escolha, cria a estrutura de diretórios abaixo; por exemplo, em sistemas *nix você pode usar o comando mkdir -p src/main/java/hello para fazer isso:

└── src
    └── main
        └── java
            └── hello

Dentro do diretório src/main/java/hello, você pode adicionar qualquer classe Java que quiser. Por questão de simplicidade e consistência, o Spring recomaenda que você crie duas classes: HelloWorld.java e Greeter.java.

src/main/java/hello/HelloWorld.java

package hello;
public class HelloWorld {
  public static void main(String[] args) {
    Greeter greeter = new Greeter();
    System.out.println(greeter.sayHello());
  }
}

src/main/java/hello/Greeter.java

package hello;
public class Greeter {
  public String sayHello() {
    return "Hello world!";
  }
}

Instalação do Gradle

Agora que você possui um projeto que pode ser compilado com o Gradle, você pode instalá-lo.

É altamente recomendável usar algum tipo de gerenciador de pacote para isso, como por exemplo Homebrew ou apt: *http://sdkman.io/ * Home brew (brew install gradle) ou apt (apt-get install gradle).

Se nenhuma das ferramentas acima atender as suas necessidades, você pode baixar um dos binários de http://www.gradle.org/downloads. Apenas os binários são necessários, então procure pelo link para o arquivo gradle-version-bin.zip. (Você pode escolher também o arquivo gradle-version-all.zip. para obter também o código fonte e a documentação).
Descompacte o arquivo em seu computador, e adicione a pasta bin em seu path.

Para testar a instalação do Gradle, execute o seguinte comando na linha de comando:

gradle

Se tudo correr bem, você verá uma mensagem de boas vindas:

:help
Welcome to Gradle 2.3.
To run a build, run gradle <task> ...
To see a list of available tasks, run gradle tasks
To see a list of command-line options, run gradle --help
BUILD SUCCESSFUL
Total time: 2.675 secs

Agora você possui o Gradle instalado.

Descubra o que o Gradle pode fazer

Agora que o Gradle foi instalado, vejamos o que você pode fazer. Antes que você crie um arquivo build.gradle para o projeto, pode verificar quais tarefas estão disponíveis:

gradle tasks

Você verá uma lista de tarefas disponíveis. Assumindo que você executou o Gradle em uma pasta que ainda não possui um arquivo build.gradle, você verá algumas tarefas elementares como:

:tasks
== All tasks runnable from root project
== Build Setup tasks
setupBuild - Initializes a new Gradle build. [incubating]
== Help tasks
dependencies - Displays all dependencies declared in root project 'gs-gradle'.
dependencyInsight - Displays the insight into a specific dependency in root project 'gs-gradle'.
help - Displays a help message
projects - Displays the sub-projects of root project 'gs-gradle'.
properties - Displays the properties of root project 'gs-gradle'.
tasks - Displays the tasks runnable from root project 'gs-gradle'.
To see all tasks and more detail, run with --all.
BUILD SUCCESSFUL
Total time: 3.077 secs

Mesmo que essas tarefas estejam disponíveis, elas não tem muito valor sem um arquivo de configuração de projeto. Quando você criar um arquivo build.gradle, algumas tarefas serão mais úteis. A lista de tarefas irá crescer a medida que você adicione plugins ao build.gradle, de forma que ocasionalmente vpcê terá que executar o comando novamente para ver quais tarefas estão disponíveis.

Falando da adição de plugins, vamos ver agora como adicionar um plugin que permite a compilação de código Java.

Crie o código Java

Para começar de forma simples, crie um arquivo build.gradle básico no diretório do seu projeto, criado no inicio desse artigo. Adicione a ele uma única linha:

apply plugin: 'java'

Essa única linha no arquivo de configuração lhe dá uma grande quantidade de recursos. Execute gradle tasks novamente, e você verá que novas tarefas foram adicionadas à lista, incluindo tarefas para compilar o projeto, criar JavaDoc, e executar testes.

Você usará a tarefa gradle build com frequência. Essa tarefa compila, testa e cria um arquivo JAR com o código. Você pode executar essa tarefa dessa forma:

gradle build

Após alguns segundos, a mensagem BUILD SUCCESSFUL indica que a compilação foi completada.

Para visualizar os resultados dessa tarefa, dê uma olhada no diretório build. Dentro dele você encontrará diversos diretórios, incluindo esses três diretórios principais:

classes. Os arquivo .class compilados do projeto.
reports. Relatórios produzidos pela compilação (como relatórios de testes).
libs. Bibliotecas do projeto (usualmente arquivos JAR ou WAR).

O diretório classes possui arquivos .class que são gerados pela compilação do código Java. Especificamente, você deve encontrar os arquivo HelloWorld.class e Greeter.class.

Nesse momento, o projeto não possui nenhuma dependência, de forma que não haverá nada no diretório dependency_cache.

O diretório reports deve conter relatórios de execução dos testes do projeto. Como o projeto ainda não possui nenhum teste, esse relatório não terá nada de interessante.

O diretório libs deve conter um arquivo JAR cujo nome é o mesmo do diretório do projeto. Mais adiante, você verá como especificar um nome e a versão para o JAR.

Declare as dependências

O Hello World do exemplo desse artigo é completamente auto-suficiente e não precisa de nenhuma biblioteca adicional. A maioria das aplicações, porém, dependem de bibliotecas externas para lidar com funcionalidades comuns ou mais complexas.

Por exemplo, suponha que além de imprimir na tela a mensagem “Hello World”, você queira que a aplicação mostre a data e hora atual. Você pode usar os recursos de data e hora das bibliotecas nativas do Java, mas pode fazer coisas mais interessantes usando as bibliotecas Joda Time.

Primeiro, altere o arquivo HelloWorld.java para dessa forma:

package hello;
import org.joda.time.LocalTime;
public class HelloWorld {
  public static void main(String[] args) {
    LocalTime currentTime = new LocalTime();
    System.out.println("The current local time is: " + currentTime);
    Greeter greeter = new Greeter();
    System.out.println(greeter.sayHello());
  }
}

Agora HelloWorld usa a classe LocalTime da biblioteca Joda Time para obter e mostra da data atual.

Se você executar gradle build para compilar o projeto nesse momento, a compilação falhará pois você não declarou a biblioteca Jode Time como uma dependência necessária para a compilação.

Para começar, você precisa adicionar uma fonte de bibliotecas de terceiros.

repositories {
    mavenCentral()
}

O bloco repositories indica que a compilação deve buscar suas dependências do repositório Maven Central. O Gradle depende bastante de muitas das convenções na ferramenta Maven, incluindo a opção de usar Maven Central como fonte de dependências.

Agora que estamos prontos para localizar bibliotecas de terceiros, vamos declarar algumas.

sourceCompatibility = 1.8
targetCompatibility = 1.8
dependencies {
    compile "joda-time:joda-time:2.2"
    testCompile "junit:junit:4.12"
}

Com o bloco dependencies, você declara uma única dependência para o Joda Time. Especificamente você está solicitando pela (lendo a linha da direita para a esquerda) versão 2.2 da biblioteca joda-time do grupo joda-time.

Uma outra coisa a ser observada em relação a essa dependência é que se trata de uma dependência do tipo compile, o que indica que ela deve estar disponível durante o momento da compilação (e se estiver criando um arquivo WAR, deve ser incluído no diretório /WEB-INF/lib dele). Outros tipos notáveis de dependência são:

providedCompile. Dependência necessárias para a compilação do código do projeto, mas serão fornecida durante a execução pelo contêiner que estiver executando a aplicação (por exemplo, a API Java Servlet).
testCompile. Dependências usadas para compilar e executar os testes, mas que não são necessárias para executar o código do projeto.

Finalmente, vamos especificar um nome para nosso JAR.

jar {
    baseName = 'gs-gradle'
    version =  '0.1.0'
}

O bloco jar especifica como o arquivo JAR será nomeado. Nesse caso, será gs-gradle-0.1.0.jar.

Agora se você executar gradle build, o Gradle deve resolver a dependência para o Joda Time no repositório Maven Central e a compilação será completada com sucesso.

Crie o seu projeto com o Gradle Wrapper

O Gradle Wrapper é a melhor forma de iniciar uma compilação com o Gradle. Consiste de um script batch para o Windows ou um script shell para OS X e Linux. Esses scripts permitem que você execute uma compilação com o Gradle sem precisar que ele esteja instalado em seu sistema. Isso costumava ser algo adicionado ao seu arquivo de configuração, mas agora é parte do Gradle, de forma que isso não é mais necessário. Ao invés disso, você simplesmente usa o seguinte comando:

$ gradle wrapper --gradle-version 2.13

Assim que essa tarefa é completada, você irá observar alguns arquivos novos. Os dois scripts estarão na raiz do diretório, enquanto o JAR encapsulador e os arquivos de propriedades foram adicionados ao diretório gradle/wrapper.

└── <project folder>
    └── gradlew
    └── gradlew.bat
    └── gradle
        └── wrapper
            └── gradle-wrapper.jar
            └── gradle-wrapper.properties

O Gradle Wrapper está disponível para a compilação de seu projeto. Adicione-o em seu sistema de controle de versões, e todos que clonarem o seu projeto poderão compila-lo da mesma forma. Pode ser usado exatamente da mesma forma que uma versão instalada do Gradle. Execute o script do Wrapper para executar a tarefa de compilação, da forma como fizemos anteriormente:

./gradlew build

Na primeira vez que você executar o Wrapper para uma versão específica do Gradle, ele irá baixar e criar um cache com os binários para essa versão. OS arquivos do Gradle Wrapper são projetados para que sejam enviados para o sistema de controle de código de forma que qualquer um possa compilar o projeto sem ter que primeiro instalar e configurar uma versão específica do Gradle.

Nessa etapa, você terá que criar o código. Você pode visualizar os resultados aqui:

build
├── classes
│   └── main
│       └── hello
│           ├── Greeter.class
│           └── HelloWorld.class
├── dependency-cache
├── libs
│   └── gs-gradle-0.1.0.jar
└── tmp
    └── jar
        └── MANIFEST.MF

Estão incluídos os dois arquivo .class esperados para Greeter e HelloWorld, assim como um arquivo JAR. Dê uma olhada nisso:

$ jar tvf build/libs/gs-gradle-0.1.0.jar
  0 Fri May 30 16:02:32 CDT 2014 META-INF/
 25 Fri May 30 16:02:32 CDT 2014 META-INF/MANIFEST.MF
  0 Fri May 30 16:02:32 CDT 2014 hello/
369 Fri May 30 16:02:32 CDT 2014 hello/Greeter.class
988 Fri May 30 16:02:32 CDT 2014 hello/HelloWorld.class

Os arquivos .class estão empacotados. É importante notar que mesmo que tenhamos declarado joda-time como dependência, a biblioteca não é incluída aqui. E o JAR não pode ser executado também.

Para tornar esse código executável, podemos usar o plugin application do Gradle. Adicione isso ao seu arquivo build.gradle:

apply plugin: 'application'
mainClassName = 'hello.HelloWorld'

Agora você pode executar a sua aplicação!

$ ./gradlew run
:compileJava UP-TO-DATE
:processResources UP-TO-DATE
:classes UP-TO-DATE
:run
The current local time is: 16:16:20.544
Hello world!
BUILD SUCCESSFUL
Total time: 3.798 secs

Para empacotar as dependência necessárias precisamos de mais algumas etapas. Por exemplo, se estiver criando um arquivo WAR, uma formato geralmente associados com o empacotamento de dependência de terceiros, podemos usar o plugin WAR do Gradle. Se estiver usando o Spring-Boot e quiser criar um arquivo JAR executável, spring-boot-gradle-plugin é bem útil. Nesse estágio, o Gradle não sabe o suficiente sobre seu sistema para fazer uma escolha. Mas por enquanto, isso deve ser o suficiente para começar a usar o Gradle.

Para empacotar todos os itens desse artigo, aqui temos o arquivo build.gradle completo:

build.gradle

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'application'
mainClassName = 'hello.HelloWorld'
// tag::repositories[]
repositories {
    mavenCentral()
}
// end::repositories[]
// tag::jar[]
jar {
    baseName = 'gs-gradle'
    version =  '0.1.0'
}
// end::jar[]
// tag::dependencies[]
sourceCompatibility = 1.8
targetCompatibility = 1.8
dependencies {
    compile "joda-time:joda-time:2.2"
    testCompile "junit:junit:4.12"
}
// end::dependencies[]
// tag::wrapper[]
// end::wrapper[]

Aqui temos diversos comentários embutidos. Isso torna possível extrair pedaços do arquivo de configuração para explicações detalhadas neste artigo. Você não precisa desses comentários em seu arquivo de produção.

Sumário

Parabéns! Você acabou de criar um arquivo de configuração para o Gradle simples mas efetivo na criação de projetos Java.

Traduzido de

spring.io