Apache Commons CLI - Guía rápida

La CLI de Apache Commons son los componentes de Apache Commons que se derivan de la API de Java y proporciona una API para analizar los argumentos / opciones de la línea de comandos que se pasan a los programas. Esta API también permite imprimir ayuda relacionada con las opciones disponibles.

El procesamiento de la línea de comandos consta de tres etapas. Estas etapas se explican a continuación:

  • Etapa de definición
  • Etapa de análisis
  • Etapa de interrogatorio

Etapa de definición

En la etapa de definición, definimos las opciones que puede tomar una aplicación y actuamos en consecuencia. Commons CLI proporciona la clase Options, que es un contenedor para los objetos Option.

// create Options object
Options options = new Options();

// add a option
options.addOption("a", false, "add two numbers");

Aquí hemos agregado un indicador de opción a, aunque falso como segundo parámetro, significa que la opción no es obligatoria y el tercer parámetro indica la descripción de la opción.

Etapa de análisis

En la etapa de análisis, analizamos las opciones pasadas usando argumentos de línea de comando después de crear una instancia del analizador.

//Create a parser
CommandLineParser parser = new DefaultParser();

//parse the options passed as command line arguments
CommandLine cmd = parser.parse( options, args);

Etapa de interrogatorio

En la etapa de interrogación, verificamos si una opción en particular está presente o no y luego procesamos el comando en consecuencia.

//hasOptions checks if option is present or not
if(cmd.hasOption("a")) {
   // add the two numbers
} else if(cmd.hasOption("m")) {
   // multiply the two numbers
}

En este capítulo, aprenderemos sobre la configuración del entorno local de Apache Commons CLI y cómo configurar la ruta de Commons CLI para Windows 2000 / XP, Windows 95/98 / ME, etc. También entenderemos algunos editores de Java populares y cómo descargar el archivo CLI de Commons.

Configuración del entorno local

Si aún está dispuesto a configurar su entorno para el lenguaje de programación Java, este capítulo lo guiará sobre cómo descargar y configurar Java en su máquina. Siga los pasos que se mencionan a continuación para configurar el entorno.

Java SE está disponible gratuitamente desde el enlace https://www.oracle.com/java/technologies/oracle-java-archive-downloads.html. Para que pueda descargar una versión basada en su sistema operativo.

Siga las instrucciones para descargar Java y ejecutar el .exe para instalar Java en su máquina. Una vez que haya instalado Java en su máquina, necesitará establecer variables de entorno para que apunten a los directorios de instalación correctos.

Ruta para Windows 2000 / XP

Suponemos que ha instalado Java en c:\Program Files\java\jdk directorio.

  • Haga clic derecho en 'My Computer' y seleccione 'Properties'.

  • Clickea en el 'Environment variables' botón debajo del 'Advanced' lengüeta.

  • Ahora, altere el 'Path'variable, para que también contenga la ruta al ejecutable de Java. Ejemplo, si la ruta está configurada actualmente en'C:\WINDOWS\SYSTEM32', luego cambia tu ruta para leer 'C:\WINDOWS\SYSTEM32;c:\Program Files\java\jdk\bin'.

Ruta para Windows 95/98 / ME

Suponemos que ha instalado Java en c:\Program Files\java\jdk directorio.

  • Edite el 'C:\autoexec.bat' archivo y agregue la siguiente línea al final - 'SET PATH=%PATH%;C:\Program Files\java\jdk\bin'.

Ruta para Linux, UNIX, Solaris, FreeBSD

La variable de entorno PATH debe establecerse en el punto donde se han instalado los binarios de Java. Consulte la documentación de su shell, si tiene problemas para hacer esto.

Por ejemplo, si usa bash como su shell, entonces agregaría la siguiente línea al final de su '.bashrc: export PATH = / path / to / java: $ PATH'

Editores populares de Java

Para escribir sus programas Java, necesita un editor de texto. Hay muchos IDE sofisticados disponibles en el mercado. Pero por ahora, puede considerar uno de los siguientes:

  • Notepad - En una máquina con Windows, puede usar cualquier editor de texto simple como el Bloc de notas (recomendado para este tutorial), TextPad.

  • Netbeans- Es un IDE de Java de código abierto y gratuito que se puede descargar de www.netbeans.org/index.html .

  • Eclipse- También es un IDE de Java desarrollado por la comunidad de código abierto de eclipse y se puede descargar de www.eclipse.org .

Descargar archivo CLI común

Descargue la última versión del archivo jar de Apache Common CLI desde commons-cli-1.4-bin.zip . En el momento de escribir este tutorial, hemos descargado commons-cli-1.4-bin.zip y lo hemos copiado en la carpeta C: \> Apache.

SO Nombre de archivo
Ventanas commons-cli-1.4-bin.zip
Linux commons-cli-1.4-bin.tar.gz
Mac commons-cli-1.4-bin.tar.gz

Entorno CLI común de Apache

Selecciona el APACHE_HOMEvariable de entorno para apuntar a la ubicación del directorio base donde, Apache jar se almacena en su máquina. Supongamos que hemos extraído commonscollections4-4.1-bin.zip en la carpeta Apache en varios sistemas operativos de la siguiente manera:

SO Salida
Ventanas Establezca la variable de entorno APACHE_HOME en C: \ Apache
Linux exportar APACHE_HOME = / usr / local / Apache
Mac exportar APACHE_HOME = / Library / Apache

Variable CLASSPATH

Selecciona el CLASSPATHvariable de entorno para apuntar a la ubicación del jar de Common CLI. Suponga que ha almacenado commons-cli-1.4.jar en la carpeta Apache en varios sistemas operativos de la siguiente manera:

SO Salida
Ventanas Almacena bots AIML </ Establece la variable de entorno CLASSPATH en% CLASSPATH%;% APACHE_HOME% \ commons-cli-1.4.jar;.;
Linux export CLASSPATH = $ CLASSPATH: $ APACHE_HOME / commons-cli-1.4.jar :.
Mac export CLASSPATH = $ CLASSPATH: $ APACHE_HOME / commons-cli-1.4.jar :.

Creemos una aplicación de muestra basada en la consola, cuyo propósito es obtener la suma de los números pasados ​​o la multiplicación de los números pasados ​​según las opciones utilizadas.

Cree una clase java llamada CLITester.

Ejemplo

CLITester.java

import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.CommandLineParser;
import org.apache.commons.cli.DefaultParser;
import org.apache.commons.cli.Options;
import org.apache.commons.cli.ParseException;
public class CLITester {
   public static void main(String[] args) throws ParseException {
      //***Definition Stage***
      // create Options object
      Options options = new Options();
      
      // add option "-a"
      options.addOption("a", false, "add numbers");
      
      // add option "-m"
      options.addOption("m", false, "multiply numbers");

      //***Parsing Stage***
      //Create a parser
      CommandLineParser parser = new DefaultParser();

      //parse the options passed as command line arguments
      CommandLine cmd = parser.parse( options, args);

      //***Interrogation Stage***
      //hasOptions checks if option is present or not
      if(cmd.hasOption("a")) {
         System.out.println("Sum of the numbers: " + getSum(args));
      } else if(cmd.hasOption("m")) {
         System.out.println("Multiplication of the numbers: " + getMultiplication(args));
      }
   }
   public static int getSum(String[] args) {
      int sum = 0;
      for(int i = 1; i < args.length ; i++) {
         sum += Integer.parseInt(args[i]);
      }
      return sum;
   }
   public static int getMultiplication(String[] args) {
      int multiplication = 1;
      for(int i = 1; i < args.length ; i++) {
         multiplication *= Integer.parseInt(args[i]);
      }
      return multiplication;
   }
}

Salida

Ejecute el archivo, pasando -a como opción y números para obtener la suma de los números como resultado.

java CLITester -a 1 2 3 4 5
Sum of the numbers: 15

Ejecute el archivo, mientras pasa -m como opción y números para obtener la multiplicación de los números como resultado.

java CLITester -m 1 2 3 4 5
Multiplication of the numbers: 120

El objeto Option se utiliza para representar la opción pasada al programa de línea de comandos. A continuación se muestran varias propiedades que posee un objeto Option.

No Señor Nombre (tipo) & amps; Descripción
1

opt (String)

Cadena de identificación de la Opción.
2

longOpt (String)

Alias ​​y cadena de identificación más descriptiva.
3

description (String)

Descripción de la función de la opción.
4

required (boolean)

Marcar para comprobar si la opción debe aparecer en la línea de comando.
5

arg (boolean)

Marcar para comprobar si la opción acepta un argumento.
6

args (boolean)

Marcar para comprobar si la opción tiene más de un argumento.
7

optionalArg (boolean)

Marcar para comprobar si el argumento de la opción es opcional.
8

argName (String)

Nombre del valor del argumento para la declaración de uso.
9

valueSeparator (char)

El valor de carácter utilizado para dividir la cadena de argumentos.
10

type (Object)

Tipo de argumento.
11

value (String)

Valor de la opción.
12

values (String[])

Valores de la opción.

Una opción booleana se representa en una línea de comando por su presencia. Por ejemplo, si la opción está presente, entonces su valor es verdadero; de lo contrario, se considera falso. Considere el siguiente ejemplo, donde imprimimos la fecha actual y si el indicador -t está presente. Luego, también imprimiremos la hora.

Ejemplo

CLITester.java

import java.util.Calendar;
import java.util.Date;

import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.CommandLineParser;
import org.apache.commons.cli.DefaultParser;
import org.apache.commons.cli.Options;
import org.apache.commons.cli.ParseException;

public class CLITester {
   public static void main(String[] args) throws ParseException {
      Options options = new Options();
      options.addOption("t", false, "display time");
      
      CommandLineParser parser = new DefaultParser();
      CommandLine cmd = parser.parse( options, args);

      Calendar date = Calendar.getInstance();
      int day = date.get(Calendar.DAY_OF_MONTH);
      int month = date.get(Calendar.MONTH);
      int year = date.get(Calendar.YEAR);

      int hour = date.get(Calendar.HOUR);
      int min = date.get(Calendar.MINUTE);
      int sec = date.get(Calendar.SECOND);

      System.out.print(day + "/" + month + "/" + year);
      if(cmd.hasOption("t")) {
         System.out.print(" " + hour + ":" + min + ":" + sec);
      }
   }
}

Salida

Ejecute el archivo sin pasar ninguna opción y vea el resultado.

java CLITester
12/11/2017

Ejecute el archivo, mientras pasa -t como opción y vea el resultado.

java CLITester
12/11/2017 4:13:10

Una opción de Argumento se representa en una línea de comando por su nombre y su valor correspondiente. Por ejemplo, si la opción está presente, el usuario debe pasar su valor. Considere el siguiente ejemplo, si estamos imprimiendo registros en algún archivo, para lo cual queremos que el usuario ingrese el nombre del archivo de registro con la opción de argumento logFile.

Ejemplo

CLITester.java

import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.CommandLineParser;
import org.apache.commons.cli.DefaultParser;
import org.apache.commons.cli.Option;
import org.apache.commons.cli.Options;
import org.apache.commons.cli.ParseException;

public class CLITester {
   public static void main(String[] args) throws ParseException {
      Options options = new Options();
      Option logfile = Option.builder()
         .longOpt("logFile")
         .argName("file" )
         .hasArg()
         .desc("use given file for log" )
         .build();

      options.addOption(logfile);
      CommandLineParser parser = new DefaultParser();
      CommandLine cmd = parser.parse( options, args);
      
      // has the logFile argument been passed?
      if(cmd.hasOption("logFile")) {
         //get the logFile argument passed
         System.out.println( cmd.getOptionValue( "logFile" ) );
      }
   }
}

Salida

Ejecute el archivo, mientras pasa --logFile como opción, nombre del archivo como valor de la opción y vea el resultado.

java CLITester --logFile test.log
test.log

Una opción de Propiedades se representa en una línea de comando por su nombre y sus propiedades correspondientes, como la sintaxis, que es similar al archivo de propiedades de Java. Considere el siguiente ejemplo, si estamos pasando opciones como -DrollNo = 1 -Dclass = VI -Dname = Mahesh, deberíamos procesar cada valor como propiedades. Veamos la lógica de implementación en acción.

Ejemplo

CLITester.java

import java.util.Properties;

import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.CommandLineParser;
import org.apache.commons.cli.DefaultParser;
import org.apache.commons.cli.Option;
import org.apache.commons.cli.Options;
import org.apache.commons.cli.ParseException;

public class CLITester {
   public static void main(String[] args) throws ParseException {
      Options options = new Options();
      Option propertyOption = Option.builder()
         .longOpt("D")
         .argName("property=value" )
         .hasArgs()
         .valueSeparator()
         .numberOfArgs(2)
         .desc("use value for given properties" )
         .build();
      
      options.addOption(propertyOption);
      CommandLineParser parser = new DefaultParser();
      CommandLine cmd = parser.parse( options, args);
      
      if(cmd.hasOption("D")) {
         Properties properties = cmd.getOptionProperties("D");
         System.out.println("Class: " + properties.getProperty("class"));
         System.out.println("Roll No: " + properties.getProperty("rollNo"));
         System.out.println("Name: " + properties.getProperty("name"));
      }
   }
}

Salida

Ejecute el archivo, mientras pasa opciones como pares clave-valor y vea el resultado.

java CLITester -DrollNo = 1 -Dclass = VI -Dname = Mahesh
Class: VI
Roll No: 1
Name: Mahesh

Se utiliza un analizador de Posix para analizar Posix como los argumentos pasados. Ahora está en desuso y es reemplazado por DefaultParser.

Ejemplo

CLITester.java

import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.CommandLineParser;
import org.apache.commons.cli.Options;
import org.apache.commons.cli.ParseException;
import org.apache.commons.cli.PosixParser;

public class CLITester {
   public static void main(String[] args) throws ParseException {
      
      //Create posix like options
      Options posixOptions = new Options();
      posixOptions.addOption("D", false, "Display");
      posixOptions.addOption("A", false, "Act");
      
      CommandLineParser posixParser = new PosixParser();
      
      CommandLine cmd = posixParser.parse(posixOptions, args);
      
      if( cmd.hasOption("D") ) {
         System.out.println("D option was used.");
      }
      if( cmd.hasOption("A") ) {
         System.out.println("A option was used.");
      }
   }
}

Salida

Ejecute el archivo mientras pasa -D -A como opciones y vea el resultado.

java CLITester -D -A
D option was used.
A option was used.

Ejecute el archivo mientras pasa --D como opción y vea el resultado.

java CLITester --D
D option was used.

Se utiliza un analizador GNU para analizar gnu como los argumentos pasados. Ahora está en desuso y se reemplaza por DefaultParser.

Ejemplo

CLITester.java

import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.CommandLineParser;
import org.apache.commons.cli.GnuParser;
import org.apache.commons.cli.Options;
import org.apache.commons.cli.ParseException;

public class CLITester {
   public static void main(String[] args) throws ParseException {
      
      //Create GNU like options
      Options gnuOptions = new Options();
      gnuOptions.addOption("p", "print", false, "Print")
         .addOption("g", "gui", false, "GUI")
         .addOption("n", true, "Scale");

      CommandLineParser gnuParser = new GnuParser();
      CommandLine cmd = gnuParser.parse(gnuOptions, args);
      
      if( cmd.hasOption("p") ) {
         System.out.println("p option was used.");
      }
      if( cmd.hasOption("g") ) {
         System.out.println("g option was used.");
      }
      if( cmd.hasOption("n") ) {
         System.out.println("Value passed: " + cmd.getOptionValue("n"));
      }
   }
}

Salida

Ejecute el archivo mientras pasa -p -g -n 10 como opción y vea el resultado.

java CLITester -p -g -n 10
p option was used.
g option was used.
Value passed: 10

Apache Commons CLI proporciona la clase HelpFormatter para imprimir la guía de uso de los argumentos de la línea de comandos. Vea el ejemplo que se da a continuación:

Ejemplo

CLITester.java

import org.apache.commons.cli.HelpFormatter;
import org.apache.commons.cli.Options;
import org.apache.commons.cli.ParseException;

public class CLITester {
   public static void main(String[] args) throws ParseException {
	
      Options options = new Options();
      options.addOption("p", "print", false, "Send print request to printer.")
         .addOption("g", "gui", false, "Show GUI Application")
         .addOption("n", true, "No. of copies to print");
			
      HelpFormatter formatter = new HelpFormatter();
      formatter.printHelp("CLITester", options);
   }
}

Salida

Ejecute el archivo y vea el resultado.

java CLITester
usage: CLITester
-g,--gui Show GUI Application
-n <arg> No. of copies to print
-p,--print Send print request to printer.

Apache Commons CLI proporciona la clase HelpFormatter para imprimir la ayuda relacionada con los argumentos de la línea de comandos. Vea el ejemplo.

Ejemplo

CLITester.java

import java.io.PrintWriter;

import org.apache.commons.cli.HelpFormatter;
import org.apache.commons.cli.Options;
import org.apache.commons.cli.ParseException;

public class CLITester {
   public static void main(String[] args) throws ParseException {
      
      Options options = new Options();
      options.addOption("p", "print", false, "Send print request to printer.")
         .addOption("g", "gui", false, "Show GUI Application")
         .addOption("n", true, "No. of copies to print");
      
      HelpFormatter formatter = new HelpFormatter();

      final PrintWriter writer = new PrintWriter(System.out);
      formatter.printUsage(writer,80,"CLITester", options);
      writer.flush();
   }
}

Salida

Ejecute el archivo y vea el resultado.

java CLITester
usage: CLITester [-g] [-n <arg>] [-p]