Argumentos da Linha de Comando em Java

Introdução

É bastante comum executar aplicações a partir da linha de comando usando argumentos. Especialmente no lado do servidor. Normalmente, não queremos que a aplicação faça a mesma coisa em cada execução: queremos configurar o seu comportamento de alguma forma.

Neste pequeno tutorial, vamos explorar como podemos lidar com os argumentos da linha de comando em Java.

Acessando argumentos de linha de comando em Java

Desde que o método principal é o ponto de entrada de uma aplicação Java, a JVM passa os argumentos de linha de comando através dos seus argumentos.

A forma tradicional é usar um array de String:

public static void main(String args) { // handle arguments}

No entanto, Java 5 introduziu varargs, que são arrays em vestuário de ovelha. Portanto, podemos definir o nosso principal com um vararg:

São idênticos, portanto a escolha entre eles depende inteiramente do gosto e preferência pessoais.

O parâmetro do método principal contém os argumentos da linha de comando na mesma ordem que passamos na execução. Se quisermos aceder a quantos argumentos obtivemos, só temos de verificar o comprimento do array.

Por exemplo, podemos imprimir o número de argumentos e o seu valor na saída padrão:

public static void main(String args) { System.out.println("Argument count: " + args.length); for (int i = 0; i < args.length; i++) { System.out.println("Argument " + i + ": " + args); }}

Nota que em algumas línguas, o primeiro argumento será o nome da aplicação. Por outro lado, em Java, esta matriz contém apenas os argumentos.

Como passar os argumentos da linha de comando

Agora que temos uma aplicação que lida com os argumentos da linha de comando, estamos ansiosos por experimentá-la. Vamos ver que opções temos.

3.1. Linha de Comando

A forma mais óbvia é a linha de comando. Vamos assumir que já compilámos a classe com.baeldung.commandlinearguments.CliExample com o nosso método principal.

Então podemos executá-lo com o seguinte comando:

java com.baeldung.commandlinearguments.CliExample

Produz a seguinte saída:

Argument count: 0

Agora, podemos passar argumentos após o nome da classe:

java com.baeldung.commandlinearguments.CliExample Hello World!

E a saída é:

Argument count: 2Argument 0: HelloArgument 1: World!

Usualmente, publicamos a nossa aplicação como um ficheiro de frasco, não como um monte de .ficheiros de classe. Digamos, embalámo-lo no cli-example.jar, e definimos com.baeldung.commandlinearguments.CliExample como a classe principal.

Agora podemos executá-lo sem argumentos da seguinte forma:

java -jar cli-example.jar

Or com argumentos:

java -jar cli-example.jar Hello World!Argument count: 2 Argument 0: Hello Argument 1: World!

Nota, que Java tratará cada argumento que passarmos após o nome da classe ou o nome do ficheiro do frasco como os argumentos da nossa aplicação. Portanto, tudo o que passamos antes disso são argumentos para a própria JVM.

3.2. Eclipse

Enquanto trabalhamos na nossa aplicação, vamos querer verificar se funciona como queremos.

Em Eclipse, podemos executar aplicações com a ajuda de configurações de execução. Por exemplo, uma configuração run define que JVM usar, qual é o ponto de entrada, o classpath, e assim por diante. E claro, podemos especificar argumentos de linha de comando.

A forma mais fácil de criar uma configuração de execução apropriada é clicar com o botão direito do rato no nosso método principal, depois escolher Run As > Aplicação Java a partir do menu de contexto:

Com isto, executamos instantaneamente a nossa aplicação com configurações que honram as configurações do nosso projecto.

Para fornecer argumentos, devemos então editar essa configuração de execução. Podemos fazê-lo através da opção de menu Run > Run Configurations…. Aqui, devemos clicar no separador Argumentos e preencher a caixa de texto Argumentos do Programa:

Hitting Run irá executar a aplicação e passar os argumentos que acabámos de introduzir.

3.3. IntelliJ

IntelliJ utiliza um processo semelhante para executar aplicações. Chama estas opções simplesmente como configurações.

P>P>Primeiro, precisamos de clicar com o botão direito do rato no método principal, depois escolher Executar ‘CliExample.main()’:

Esta irá executar o nosso programa, mas irá também adicioná-lo à lista de execução para configuração posterior.

Então, para configurar argumentos, devemos escolher Run > Editar Configurações… e editar a caixa de texto de argumentos do Programa:

Depois disso, devemos premir OK e voltar a executar a nossa aplicação, por exemplo com o botão Run na barra de ferramentas.

3.4. NetBeans

NetBeans também se adequa aos seus processos de execução e configuração.

Devemos executar a nossa aplicação primeiro clicando com o botão direito do rato no método principal e escolhendo Run File:

p>Like antes, isto cria uma configuração de execução e executa o programa.

Next, temos de configurar os argumentos nessa configuração de execução. Podemos fazer isso escolhendo Run > Set Project Configuration > Customize… Depois devemos Executar à esquerda e preencher o campo de texto Arguments:

Após isso, devemos clicar em OK e iniciar a aplicação.

Terceira Bibliotecas

A manipulação manual dos argumentos da linha de comando é directa em cenários simples. Contudo, à medida que os nossos requisitos se tornam cada vez mais complexos, o mesmo acontece com o nosso código. Portanto, se quisermos criar uma aplicação com múltiplas opções de linha de comando, seria mais fácil utilizar uma biblioteca de terceiros.

Felizmente, existe uma pletora das bibliotecas que suportam a maioria dos casos de utilização. Dois exemplos populares são Picocli e Spring Shell.

Conclusion

É sempre uma boa ideia tornar o comportamento da sua aplicação configurável. Neste artigo, vimos como fazer isso usando argumentos de linha de comando. Além disso, abordámos várias formas de passar esses argumentos.

Como de costume, os exemplos estão disponíveis no GitHub.