TOC

Executar um método principal Java usando Gradle

Executar um método principal Java usando Gradle

1. Introdução

Neste tutorial, vamos explorar os diferentes métodos de execução deJava main method usando o Gradle.

2. Método Javamain

Existem várias maneiras de executar um método Javamain com o Gradle. Vamos examiná-los de perto usando um programa simples que imprime uma mensagem na saída padrão: 

public class MainClass {
    public static void main(String[] args) {
        System.out.println("Goodbye cruel world ...");
    }
}

3. Executando com o plug-in de aplicativo

O plug-in de aplicativo é um plug-in principal do Gradle que define uma coleção de tarefas prontas para uso que nos ajudam a empacotar e distribuir nosso aplicativo.

Vamos começar inserindo o seguinte em nosso arquivobuild.gradle: 

plugins {
    id "application"
}
apply plugin : "java"
ext {
   javaMainClass = "com.example.gradle.exec.MainClass"
}

application {
    mainClassName = javaMainClass
}

O plugin gera automaticamente uma tarefa chamadarun que requer apenas que apontemos para a classemain. O fechamento na linha 9 faz exatamente isso, o que nos permite acionar a tarefa: 

~/work/example/tutorials/gradle-java-exec> ./gradlew run

> Task :run
Goodbye cruel world ...

BUILD SUCCESSFUL in 531ms
2 actionable tasks: 1 executed, 1 up-to-date

4. Executando com a tarefaJavaExec

A seguir, vamos implementar uma tarefa personalizada para executar o métodomain com a ajuda do tipo de tarefaJavaExec: 

task runWithJavaExec(type: JavaExec) {
    group = "Execution"
    description = "Run the main class with JavaExecTask"
    classpath = sourceSets.main.runtimeClasspath
    main = javaMainClass
}

Precisamos definir a classemain na linha 5 e, adicionalmente, especificar o caminho de classe. O caminho de classe é calculado a partir das propriedades padrão da saída da compilação e contém o caminho correto onde a classe compilada é realmente colocada.

Observe que em cada cenário, nósuse the fully qualified name, including package, of the main class.

Vamos executar nosso exemplo usandoJavaExec: 

~/work/example/tutorials/gradle-java-exec> ./gradlew runWithJavaExec

> Task :runWithJavaExec
Goodbye cruel world ...

BUILD SUCCESSFUL in 526ms
2 actionable tasks: 1 executed, 1 up-to-date

5. Executando com a tarefaExec

Finalmente, podemos executar nossa classemain usando o tipo de tarefa baseExec. Uma vez que esta opção nos oferece a possibilidade de configurar a execução de várias maneiras, vamos implementar três tarefas personalizadas e discuti-las individualmente.

5.1. Executando a partir da Saída de Compilação Compilada

Primeiro, criamos uma tarefaExec personalizada que se comporta de forma semelhante aJavaExec: 

task runWithExec(type: Exec) {
    dependsOn build
    group = "Execution"
    description = "Run the main class with ExecTask"
    commandLine "java", "-classpath", sourceSets.main.runtimeClasspath.getAsPath(), javaMainClass
}

Podemos executar qualquer executável (neste caso, java) e passar os argumentos necessários para que seja executado.

Configuramos o caminho de classe e apontamos para nossa classemain na linha 5, e também adicionamos uma dependência à tarefabuild na linha 2. Isso é necessário, pois só podemos executar nossa classemain depois de compilada: 

~/work/example/tutorials/gradle-java-exec> ./gradlew runWithExec

> Task :runWithExec
Goodbye cruel world ...

BUILD SUCCESSFUL in 666ms
6 actionable tasks: 6 executed

5.2. Executando a partir de um Jar de Saída

A segunda abordagem se baseia no empacotamento de jar do nosso pequeno aplicativo: 

task runWithExecJarOnClassPath(type: Exec) {
    dependsOn jar
    group = "Execution"
    description = "Run the mainClass from the output jar in classpath with ExecTask"
    commandLine "java", "-classpath", jar.archiveFile.get(), javaMainClass
}

Observe a dependência da tarefa jar na linha 2 e o segundo argumento do executável java na linha 5. We use a normal jar, so we need to specify the entry point with the fourth parameter: 

~/work/example/tutorials/gradle-java-exec> ./gradlew runWithExecJarOnClassPath

> Task :runWithExecJarOnClassPath
Goodbye cruel world ...

BUILD SUCCESSFUL in 555ms
3 actionable tasks: 3 executed

5.3. Executando a partir de um Jar de Saída Executável

A terceira forma também depende da embalagem do frasco, mas definimos o ponto de entrada com a ajuda de uma propriedademanifest: 

jar {
    manifest {
        attributes(
            "Main-Class": javaMainClass
        )
    }
}

task runWithExecJarExecutable(type: Exec) {
    dependsOn jar
    group = "Execution"
    description = "Run the output executable jar with ExecTask"
    commandLine "java", "-jar", jar.archiveFile.get()
}

Aqui,we no longer need to specify the classpath, e podemos simplesmente executar o jar: 

~/work/example/tutorials/gradle-java-exec> ./gradlew runWithExecJarExecutable

> Task :runWithExecJarExecutable
Goodbye cruel world ...

BUILD SUCCESSFUL in 572ms
3 actionable tasks: 3 executed

6. Conclusão

Neste artigo, exploramos as várias maneiras de executar um método Javamain usando o Gradle.

Pronto para uso, o plug-in de aplicativo fornece uma tarefa minimamente configurável para executar nosso método. O tipo de tarefaJavaExec nos permite executar o métodomain sem especificar nenhum plug-in.

Finalmente, o tipo de tarefaExec genérico pode ser usado em várias combinações com o executável java para obter os mesmos resultados, mas requer uma dependência de outras tarefas.

Como de costume, o código-fonte deste tutorial está disponívelover on GitHub.

Related