¿Cómo analizo los argumentos de línea de comando en Java?

¿Cuál es una buena forma de analizar argumentos de línea de comandos en Java?

Mira esto:

O hazlo tu mismo:


Por ejemplo, así es como usas commons-cli para analizar 2 argumentos de cadena:

 import org.apache.commons.cli.*; public class Main { public static void main(String[] args) throws Exception { Options options = new Options(); Option input = new Option("i", "input", true, "input file path"); input.setRequired(true); options.addOption(input); Option output = new Option("o", "output", true, "output file"); output.setRequired(true); options.addOption(output); CommandLineParser parser = new DefaultParser(); HelpFormatter formatter = new HelpFormatter(); CommandLine cmd; try { cmd = parser.parse(options, args); } catch (ParseException e) { System.out.println(e.getMessage()); formatter.printHelp("utility-name", options); System.exit(1); } String inputFilePath = cmd.getOptionValue("input"); String outputFilePath = cmd.getOptionValue("output"); System.out.println(inputFilePath); System.out.println(outputFilePath); } } 

uso de línea de comando:

 $> java -jar target/my-utility.jar -i asd Missing required option: o usage: utility-name -i,--input  input file path -o,--output  output file 

Eche un vistazo al JCommander más reciente.

Lo creé Me complace recibir preguntas o solicitudes de funciones.

He estado tratando de mantener una lista de analizadores CLI de Java .

  • Aerolínea
  • argparse4j
  • argparser
  • args4j
  • clajr
  • cli-analizador
  • CmdLn
  • Línea de comando
  • DocOpt.java
  • dolphin getopt
  • DPML CLI (horquilla CLI2 de Jakarta Commons)
  • Dr. Matthias Laux
  • Jakarta Commons CLI
  • Jargo
  • jargp
  • jargs
  • java-getopt
  • jbock
  • JCLAP
  • jcmdline
  • jcommander
  • jcommando
  • jewelcli (escrito por mí)
  • JOpt simple
  • jsap
  • naturalcli
  • Artículo Object Mentor CLI (más sobre refactorización y TDD)
  • parse-cmd
  • ritopt
  • Rop
  • Comando TE-Code
  • picocli tiene ayuda de uso coloreada ANSI y autocompletar

He usado JOpt y he encontrado que es muy útil: http://jopt-simple.sourceforge.net/

La página principal también proporciona una lista de aproximadamente 8 bibliotecas alternativas, compruébalo y escoge el que más se ajuste a tus necesidades.

Alguien me señaló args4j últimamente, que está basado en anotaciones. ¡Me gusta mucho!

Esta es la biblioteca de análisis de línea de comandos de Google de código abierto como parte del proyecto Bazel. Personalmente, creo que es el mejor, mucho más fácil que Apache CLI.

https://github.com/pcj/google-options

Instalación

Bazel

 maven_jar( name = "com_github_pcj_google_options", artifact = "com.github.pcj:google-options:jar:1.0.0", sha1 = "85d54fe6771e5ff0d54827b0a3315c3e12fdd0c7", ) 

Gradle

 dependencies { compile 'com.github.pcj:google-options:1.0.0' } 

Maven

  com.github.pcj google-options 1.0.0  

Uso

Cree una clase que amplíe OptionsBase y defina su @Option (s).

 package example; import com.google.devtools.common.options.Option; import com.google.devtools.common.options.OptionsBase; import java.util.List; /** * Command-line options definition for example server. */ public class ServerOptions extends OptionsBase { @Option( name = "help", abbrev = 'h', help = "Prints usage info.", defaultValue = "true" ) public boolean help; @Option( name = "host", abbrev = 'o', help = "The server host.", category = "startup", defaultValue = "" ) public String host; @Option( name = "port", abbrev = 'p', help = "The server port.", category = "startup", defaultValue = "8080" ) public int port; @Option( name = "dir", abbrev = 'd', help = "Name of directory to serve static files.", category = "startup", allowMultiple = true, defaultValue = "" ) public List dirs; } 

Analiza los argumentos y úsalos.

 package example; import com.google.devtools.common.options.OptionsParser; import java.util.Collections; public class Server { public static void main(String[] args) { OptionsParser parser = OptionsParser.newOptionsParser(ServerOptions.class); parser.parseAndExitUponError(args); ServerOptions options = parser.getOptions(ServerOptions.class); if (options.host.isEmpty() || options.port < 0 || options.dirs.isEmpty()) { printUsage(parser); return; } System.out.format("Starting server at %s:%d...\n", options.host, options.port); for (String dirname : options.dirs) { System.out.format("\\--> Serving static files at <%s>\n", dirname); } } private static void printUsage(OptionsParser parser) { System.out.println("Usage: java -jar server.jar OPTIONS"); System.out.println(parser.describeOptions(Collections.emptyMap(), OptionsParser.HelpVerbosity.LONG)); } } 

https://github.com/pcj/google-options

Echa un vistazo al proyecto CLI de Commons , hay muchas cosas buenas ahí.

Yeap.

Creo que estás buscando algo como esto: http://commons.apache.org/cli

La biblioteca CLI de Apache Commons proporciona una API para procesar interfaces de línea de comando.

Tal vez estos

  • picocli “una poderosa interfaz de línea de comando pequeña” . Picocli es una biblioteca de analizador de argumentos de línea de comando para Java, con ayuda de uso de color ANSI y finalización de línea de comando. Los subcomandos nesteds, el manual de usuario detallado y la capacidad de incluir como fuente para evitar depender del pico de picocli también son dignos de mención.
  • Conjunto de análisis de opciones de línea de comandos de JArgs para Java : este pequeño proyecto proporciona un conjunto de analizadores de opciones de línea de comandos conveniente, compacto, preempaquetado y ampliamente documentado para el uso de progtwigdores de Java. Inicialmente, se proporciona un análisis sintáctico compatible con el estilo de GNU ‘getopt’.

  • ritopt, The Ultimate Options Parser para Java : aunque se han propuesto varios estándares de opciones de línea de comandos, ritopt sigue las convenciones prescritas en el paquete opt.

Puede encontrar este metaartículo de infelicidad interesante como punto de partida:

http://furiouspurpose.blogspot.com/2008/07/command-line-parsing-libraries-for-java.html

Escribí otro: http://argparse4j.sourceforge.net/

Argparse4j es una biblioteca de analizador de argumentos de línea de comandos para Java, basada en argparse de Python.

Comprar o construir?

Muchas aplicaciones pequeñas similares a utilidades probablemente tengan su propio análisis de línea de comando para evitar la dependencia externa adicional.

picocli puede ser interesante. Está diseñado para ser incluido como fuente como una alternativa más simple a los tarros de sombreado en un uberjar.

Otra característica que te puede gustar es su ayuda de uso coloreada.

Ayuda mínima de uso con colores ANSI

Funciones del analizador:

  • Basado en anotaciones: el análisis es una línea de código
  • Todo fuertemente tipeado – opciones de línea de comando así como parámetros posicionales
  • Opciones cortas agrupadas de POSIX ( -xvfInputFile así como -x -v -f InputFile )
  • Un modelo arity que permite un número mínimo, máximo y variable de parámetros, por ejemplo, "1..*" , "3..5"
  • Subcomandos (se pueden anidar a profundidad arbitraria)
  • Funciona con Java 5 y superior

El mensaje de ayuda de uso es fácil de personalizar con anotaciones (sin progtwigción). Por ejemplo:

Mensaje de ayuda de uso extendido ( fuente )

No pude resistirme a agregar una captura de pantalla más para mostrar qué mensajes de ayuda de uso son posibles. La ayuda de uso es la cara de tu aplicación, ¡sé creativo y diviértete!

picocli demo

Descargo de responsabilidad: Creé picocli. Comentarios o preguntas muy bienvenidas.

la aerolínea @ Github se ve bien. Se basa en la anotación e intenta emular las estructuras de línea de comando de Git.

No recomendaría el uso de la biblioteca de CLI común de Apache, ya que no es segura para los hilos. Utiliza clases con estado con variables estáticas y métodos para hacer el trabajo interno (por ejemplo, OptionBuilder) y solo debe usarse en situaciones de un solo hilo fuertemente controladas.

Sé que la mayoría de las personas aquí encontrarán 10 millones de razones por las cuales no les gusta mi forma de ser, pero no importa. Me gusta mantener las cosas simples, así que simplemente separe la llave del valor usando un ‘=’ y almacénelas en un HashMap de la siguiente manera:

 Map argsMap = new HashMap<>(); for (String arg: args) { String[] parts = arg.split("="); argsMap.put(parts[0], parts[1]); } 

Siempre puede mantener una lista con los argumentos que espera, para ayudar al usuario en caso de que haya olvidado un argumento o utilizado uno equivocado … Sin embargo, si desea tener demasiadas funciones, esta solución no es para usted de todos modos.

Si quieres algo ligero (tamaño de jar ~ 20 kb) y fácil de usar, puedes probar argument-parser . Se puede usar en la mayoría de los casos de uso, admite especificar matrices en el argumento y no tiene dependencia de ninguna otra biblioteca. Funciona para Java 1.5 o superior. El siguiente fragmento muestra un ejemplo sobre cómo usarlo:

 public static void main(String[] args) { String usage = "--day|-d day --mon|-m month [--year|-y year][--dir|-ds directoriesToSearch]"; ArgumentParser argParser = new ArgumentParser(usage, InputData.class); InputData inputData = (InputData) argParser.parse(args); showData(inputData); new StatsGenerator().generateStats(inputData); } 

Más ejemplos se pueden encontrar aquí

Argparse4j es lo mejor que he encontrado. Imita la biblioteca argparse de Python, que es muy conveniente y poderosa.

Como uno de los comentarios mencionados anteriormente ( https://github.com/pcj/google-options ) sería una buena opción para comenzar.

Una cosa que quiero agregar es:

1) Si se encuentra con algún error de reflexión del analizador, intente utilizar una versión más nueva de la guayaba. en mi caso:

 maven_jar( name = "com_google_guava_guava", artifact = "com.google.guava:guava:19.0", server = "maven2_server", ) maven_jar( name = "com_github_pcj_google_options", artifact = "com.github.pcj:google-options:jar:1.0.0", server = "maven2_server", ) maven_server( name = "maven2_server", url = "http://central.maven.org/maven2/", ) 

2) Cuando se ejecuta la línea de comando:

 bazel run path/to/your:project -- --var1 something --var2 something -v something 

3) Cuando necesite la ayuda de uso, simplemente escriba:

 bazel run path/to/your:project -- --help