Argumentos de linha de comando em Java

1. Introdução

É bastante comum executar aplicativos na linha de comando usando argumentos. Especialmente no lado do servidor. Usually, we don’t want the application to do the same thing on every run: we want to configure it’s behavior some way.

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

2. Acessando argumentos de linha de comando em Java

Como o métodomain é o ponto de entrada de um aplicativo Java, a JVM passa os argumentos da linha de comando por meio de seus argumentos.

A maneira tradicional é usar uma matrizString:

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

No entanto, Java 5 introduziu varargs, que são matrizes em pele de ovelha. Portanto, podemos definir nossomain com uma varargString:

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

Eles são idênticos, portanto, escolher entre eles depende inteiramente do gosto e preferência pessoal.

The method parameter of the main method contains the command-line arguments in the same order we passed at execution. Se quisermos acessar quantos argumentos obtivemos, só temos que verificar olength do array.

Por exemplo, podemos imprimir o número de argumentos e 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[i]);
    }
}

Observe que em alguns idiomas, o primeiro argumento será o nome do aplicativo. Por outro lado, em Java, essa matriz contém apenas os argumentos.

3. Como passar argumentos de linha de comando

Agora que temos um aplicativo que lida com argumentos de linha de comando, estamos ansiosos para experimentá-lo. Vamos ver quais opções temos.

3.1. Linha de comando

A maneira mais óbvia é a linha de comando. Vamos supor que já compilamos a classecom.example.commandlinearguments.CliExample com nosso métodomain nela.

Em seguida, podemos executá-lo com o seguinte comando:

java com.example.commandlinearguments.CliExample

Produz a seguinte saída:

Argument count: 0

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

java com.example.commandlinearguments.CliExample Hello World!

E a saída é:

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

Normalmente, publicamos nosso aplicativo como um arquivo jar, não como um monte de arquivos.class. Digamos que o empacotamos emcli-example.jar e definimoscom.example.commandlinearguments.CliExample como a classe principal.

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

java -jar cli-example.jar

Ou com argumentos:

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

Observe queJava will treat every argument we pass after the class name or the jar file name as the arguments of our application. Portanto, tudo o que passamos antes são argumentos para a própria JVM.

3.2. Eclipse

Enquanto trabalhamos em nosso aplicativo, gostaríamos de verificar se ele funciona da maneira que desejamos.

No Eclipse, podemos executar aplicativos com a ajuda de configurações de execução. Por exemplo, uma configuração de execução define qual JVM usar, qual é o ponto de entrada, o caminho de classe e assim por diante. E, é claro, podemos especificar argumentos da linha de comando.

A maneira mais fácil de criar uma configuração de execução apropriada é clicar com o botão direito do mouse em nosso métodomain e escolherRun As > Java Application no menu de contexto:

Com isso, executamos instantaneamente nosso aplicativo com configurações que respeitam as configurações do projeto.

Para fornecer argumentos, devemos editar a configuração de execução. Podemos fazer isso por meio da opção de menuRun > Run Configurations…. Aqui, devemos clicar na guiaArguments e preencher a caixa de textoProgram arguments:

PressionarRun executará o aplicativo e passará os argumentos que acabamos de inserir.

3.3. IntelliJ

O IntelliJ usa um processo semelhante para executar aplicativos. Chama essas opções simplesmente como configurações.

Primeiro, precisamos clicar com o botão direito no métodomain e, em seguida, escolherRun ‘CliExample.main()':

Isso executará nosso programa, mas também o adicionará à listaRun para configuração posterior.

Então, para configurar os argumentos, devemos escolherRun > Edit Configurations…e editar a caixa de textoProgram arguments:

Depois disso, devemos clicar em OK e executar novamente o aplicativo, por exemplo, com o botão executar na barra de ferramentas.

3.4. NetBeans

O NetBeans também se alinha com seus processos de execução e configuração.

Devemos executar nosso aplicativo primeiro clicando com o botão direito no métodomaine escolhendoRun File:

Como antes, isso cria uma configuração de execução e executa o programa.

Em seguida, temos que configurar os argumentos nessa configuração de execução. Podemos fazer isso escolhendoRun > Set Project Configuration > Customize… Então devemosRun à esquerda e preencher o campo de textoArguments:

Depois disso, devemos pressionar OK e iniciar o aplicativo.

4. Bibliotecas de terceiros

Manual handling of the command-line arguments is straightforward in simple scenarios. However, as our requirements become more and more complex, so does our code. Portanto, se quisermos criar um aplicativo com várias opções de linha de comando, seria mais fácil usar uma biblioteca de terceiros.

Felizmente, há uma infinidade dessas bibliotecas que oferecem suporte à maioria dos casos de uso. Dois exemplos populares sãoPicocli eSpring Shell.

5. Conclusão

É sempre uma boa ideia tornar o comportamento de seu aplicativo configurável. Neste artigo, vimos como fazer isso usando argumentos de linha de comando. Além disso, abordamos várias maneiras de passar esses argumentos.

Como de costume, os exemplos estão disponíveisover on GitHub.

TOC

Argumentos de linha de comando em Java