Argumentos de la línea de comandos en Java

1. Introducción

Es bastante común ejecutar aplicaciones desde la línea de comandos usando argumentos. Especialmente en el lado del servidor. Por lo general, no queremos que la aplicación haga lo mismo en cada ejecución: queremos configurar su comportamiento de alguna manera.

En este breve tutorial, exploraremos cómo podemos manejar argumentos de línea de comandos en Java.

2. Acceso a argumentos de la línea de comandos en Java

Dado que el método principal es el punto de entrada de una aplicación Java, la JVM pasa los argumentos de la línea de comandos a través de sus argumentos.

La forma tradicional es usar una matriz de cadenas :

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

Sin embargo, Java 5 introdujo varargs, que son matrices con piel de oveja. Por lo tanto, podemos definir nuestro main con un String vararg:

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

Son idénticos, por lo que elegir entre ellos depende totalmente del gusto y las preferencias personales.

El parámetro de método del método principal contiene los argumentos de la línea de comandos en el mismo orden que pasamos en la ejecución. Si queremos acceder a la cantidad de argumentos que obtuvimos, solo tenemos que verificar la longitud de la matriz.

Por ejemplo, podemos imprimir el número de argumentos y su valor en la salida estándar:

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]); } }

Tenga en cuenta que en algunos idiomas, el primer argumento será el nombre de la aplicación. Por otro lado, en Java, esta matriz contiene solo los argumentos.

3. Cómo pasar argumentos en la línea de comandos

Ahora que tenemos una aplicación que maneja argumentos de línea de comandos, estamos ansiosos por probarla. Veamos qué opciones tenemos.

3.1. Línea de comando

La forma más obvia es la línea de comandos. Supongamos que ya compilamos la clase com.baeldung.commandlinearguments.CliExample con nuestro método principal en ella.

Entonces podemos ejecutarlo con el siguiente comando:

java com.baeldung.commandlinearguments.CliExample

Produce la siguiente salida:

Argument count: 0

Ahora, podemos pasar argumentos después del nombre de la clase:

java com.baeldung.commandlinearguments.CliExample Hello World!

Y la salida es:

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

Por lo general, publicamos nuestra aplicación como un archivo jar, no como un grupo de archivos .class . Digamos que lo empaquetamos en cli-example.jar y configuramos com.baeldung.commandlinearguments.CliExample como la clase principal.

Ahora podemos ejecutarlo sin argumentos de la siguiente manera:

java -jar cli-example.jar

O con argumentos:

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

Tenga en cuenta que Java tratará cada argumento que pase después del nombre de la clase o del archivo jar como argumentos de nuestra aplicación . Por lo tanto, todo lo que pasamos antes son argumentos para la propia JVM.

3.2. Eclipse

Mientras trabajamos en nuestra aplicación, queremos comprobar si funciona como queremos.

En Eclipse, podemos ejecutar aplicaciones con la ayuda de configuraciones de ejecución. Por ejemplo, una configuración de ejecución define qué JVM utilizar, cuál es el punto de entrada, la ruta de clases, etc. Y, por supuesto, podemos especificar argumentos en la línea de comandos.

La forma más fácil de crear una configuración de ejecución adecuada es hacer clic con el botón derecho en nuestro método principal y luego seleccionar Ejecutar como> Aplicación Java en el menú contextual:

Con esto, ejecutamos instantáneamente nuestra aplicación con configuraciones que respetan la configuración de nuestro proyecto.

Para proporcionar argumentos, debemos editar esa configuración de ejecución. Podemos hacerlo a través de la opción de menú Ejecutar> Ejecutar configuraciones… . Aquí, debemos hacer clic en la pestaña Argumentos y completar el cuadro de texto Argumentos del programa :

Presionar Ejecutar ejecutará la aplicación y pasará los argumentos que acabamos de ingresar.

3.3. IntelliJ

IntelliJ usa un proceso similar para ejecutar aplicaciones. Llama a estas opciones simplemente como configuraciones.

Primero, debemos hacer clic derecho en el método principal , luego elegir Ejecutar 'CliExample.main ()':

This will run our program, but it will also add it to the Run list for further configuration.

So, then to configure arguments, we should choose Run > Edit Configurations… and edit the Program arguments textbox:

After that, we should hit OK and rerun our application, for example with the run button in the toolbar.

3.4. NetBeans

NetBeans also falls into line with its running and configuration processes.

We should run our application first by right-clicking on the main method and choosing Run File:

Like before, this creates a run configuration and runs the program.

Next, we have to configure the arguments in that run configuration. We can do that by choosing Run > Set Project Configuration > Customize… Then we should Run on the left and fill the Arguments text field:

After that, we should hit OK and start the application.

4. Third-Party Libraries

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. Therefore, if we want to create an application with multiple command-line options, it would be easier to use a third-party library.

Fortunately, there're a plethora of those libraries which support most use cases. Two popular examples are Picocli and Spring Shell.

5. Conclusion

Siempre es una buena idea configurar el comportamiento de su aplicación. En este artículo, vimos cómo hacerlo usando argumentos de línea de comandos. Además, cubrimos varias formas de aprobar esos argumentos.

Como de costumbre, los ejemplos están disponibles en GitHub.