programa - que son los parámetros o argumentos en java

¿Cómo puedo analizar los argumentos de la línea de comandos en Java?

Question

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

Answer 1

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

Answer 2

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

Answer 3

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 encuentra 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) Al ejecutar la línea de comandos:

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

Answer 4

Comprar o construir?

Es probable que muchas aplicaciones pequeñas de tipo utilidad utilicen su propio análisis de línea de comandos para evitar la dependencia externa adicional.

picocli puede ser interesante. Está diseñado para ser incluido como fuente como una alternativa más simple para sombrear los frascos en un uberjar.

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

Características del analizador:

• Anotación basada: el análisis es una línea de código
• Se escribe todo con fuerza: opciones de línea de comando y parámetros posicionales
• POSIX opciones cortas agrupadas ( <command> -xvfInputFile así como <command> -x -v -f InputFile )
• Un modelo de aridad que permite un número mínimo, máximo y variable de parámetros, por ejemplo, "1..*" , "3..5"
• Subcomandos (pueden ser anidados a profundidad arbitraria)
• Funciona con Java 5 y superior

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

( source )

No pude resistir agregar una captura de pantalla más para mostrar qué mensajes de ayuda son posibles. La ayuda de uso es la cara de su aplicación, ¡así que sea creativo y diviértase!

Descargo de responsabilidad: he creado picocli. Comentarios o preguntas muy bienvenidos.

Answer 5

Echa un vistazo a la más reciente JCommander .

Yo lo creé. Estoy feliz de recibir preguntas o solicitudes de características.

Answer 6

Echa un vistazo al proyecto http://commons.apache.org/cli/ , hay muchas cosas buenas allí.

Answer 7

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

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

Answer 8

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, y mucho más fácil que el CLI de Apache.

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

<dependency>
  <groupId>com.github.pcj</groupId>
  <artifactId>google-options</artifactId>
  <version>1.0.0</version>
</dependency>

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<String> dirs;

}

Analizar los argumentos y usarlos.

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.<String, String>emptyMap(),
                                              OptionsParser.HelpVerbosity.LONG));
  }

}

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

Answer 9

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

• Airline
  • Horquilla activa: https://github.com/rvesse/airline
• argparse4j
• argparser
• args4j
• clajr
• cli-parser
• CmdLn
• Commandline
• DocOpt.java
• Dolphin Getopt
• DPML CLI (horquilla Jakarta Commons CLI2)
• Dr. Matthias Laux
• Jakarta Commons CLI
• jargo
• jargp
• jargs
• java-getopt
• jbock
• JCLAP
• jcmdline
• JCommander
• jcommando
• jewelcli (escrito por mi)
• http://jopt-simple.sourceforge.net/
• http://www.martiansoftware.com/jsap/
• naturalcli
• Artículo de Object Mentor CLI (más sobre refactorización y TDD)
• parse-cmd
• ritopt
• Rop
• Comando de código TE
• picocli tiene ayuda de uso coloreada ANSI y autocompletar

Answer 10

He usado JOpt y lo encontré bastante útil: http://jopt-simple.sourceforge.net/

La página de inicio también proporciona una lista de aproximadamente 8 bibliotecas alternativas, revíselas y elija la que más se ajuste a sus necesidades.

Answer 11

No recomendaría usar la biblioteca CLI de Apache Common, ya que no es segura para subprocesos. Utiliza clases con estado con variables estáticas y métodos para realizar trabajos internos (por ejemplo, OptionBuilder) y solo debe usarse en situaciones de un solo hilo fuertemente controladas.

Answer 12

Para los usuarios de Spring, debemos mencionar también https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/core/env/SimpleCommandLinePropertySource.html y su hermano gemelo https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/core/env/JOptCommandLinePropertySource.html (implementación de JOpt de la misma funcionalidad). La ventaja de Spring es que puede vincular directamente los argumentos de la línea de comandos a los atributos, aquí hay un ejemplo https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/core/env/CommandLinePropertySource.html

Answer 13

Podría encontrar este meta-artículo de infelicidad interesante como punto de partida:

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

Answer 14

Sé que la mayoría de la gente aquí va a encontrar 10 millones de razones por las que no les gusta mi manera, pero no importa. Me gusta mantener las cosas simples, así que simplemente separo la clave del valor con un ''='' y las guardo en un HashMap como este:

Map<String, String> 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 haya utilizado uno incorrecto ... Sin embargo, si desea demasiadas funciones, esta solución no es para usted de todos modos.

Answer 15

Si desea algo liviano (tamaño de frasco de ~ 20 kb) y fácil de usar, puede probar argument-parser . Se puede usar en la mayoría de los casos de uso, admite la especificación de matrices en el argumento y no tiene dependencia de ninguna otra biblioteca. Funciona para Java 1.5 o superior. El siguiente extracto muestra un ejemplo de 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 here

Answer 16

Si está familiarizado con gnu getopt, hay un puerto Java en: http://www.urbanophile.com/arenn/hacking/download.htm .

Parece que hay algunas clases que hacen esto:

• http://docs.sun.com/source/816-5618-10/netscape/ldap/util/GetOpt.html
• http://xml.apache.org/xalan-j/apidocs/org/apache/xalan/xsltc/cmdline/getopt/GetOpt.html

Answer 17

Tal vez estos

• picocli "una poderosa pequeña interfaz de línea de comandos" . Picocli es una biblioteca de analizadores de argumentos de línea de comandos para Java, con ayuda de color ANSI y finalización de la línea de comandos. Los subcomandos anidados, el manual del usuario detallado y la capacidad de incluir como fuente para evitar depender del frasco de Picocli también son notables.

• jargs : este pequeño proyecto proporciona un conjunto de analizadores de opciones de línea de comando convenientes, compactos, preempaquetados y ampliamente documentados para el uso de programadores de Java. Inicialmente, se proporciona un análisis compatible con el estilo GNU ''getopt''.

• ritopt : aunque se han preparado varios estándares de opciones de línea de comandos, ritopt sigue las convenciones prescritas en el paquete opt.

Answer 18

Una estrella en ascenso reciente es picocli (colores ANSI, autocompletado de línea de comandos, anotaciones y API programática, y más).

También puedes ver estos (mayores):

• http://commons.apache.org/cli/
• http://www.martiansoftware.com/jsap/

O enrolla tu propio

• http://docs.oracle.com/javase/7/docs/api/java/util/Scanner.html

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 desde la línea de comando:

$> java -jar target/my-utility.jar -i asd                                                                                       
Missing required option: o

usage: utility-name
 -i,--input <arg>    input file path
 -o,--output <arg>   output file

Answer 19

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 comandos.

Answer 20

Airline ve bien. Se basa en la anotación y está intentando emular las estructuras de línea de comandos de Git.