Qual è un buon modo per analizzare gli argomenti della riga di comando in Java?

Dai un'occhiata a questi:

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

O fai il tuo:

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

Ad esempio, è così che si usa commons-cliper analizzare 2 argomenti stringa:

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

    }

}

utilizzo dalla riga di 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

Dai un'occhiata al più recente JCommander .

L'ho creato io. Sono felice di ricevere domande o richieste di funzionalità.

Ho cercato di mantenere un elenco di parser della CLI Java .

• linea aerea
  • Active Fork: https://github.com/rvesse/airline
• argparse4j
• argparser
• args4j
• clajr
• cli-parser
• CmdLn
• Riga di comando
• DocOpt.java
• getft delfino
• DPML CLI (fork CLI2 di Jakarta Commons)
• Dr. Matthias Laux
• Jakarta Commons CLI
• Jargo
• jargp
• jargs
• java-getopt
• jbock
• JCLAP
• jcmdline
• jcommander
• jcommando
• jewelcli (scritto da me)
• JOpt semplice
• JSAP
• naturalcli
• Articolo CLI di Mentor oggetto (maggiori informazioni su refactoring e TDD)
• parse-cmd
• ritopt
• Rop
• Comando TE-Code
• picocli ha una guida all'uso ANSI colorata e il completamento automatico

È il 2020, è tempo di fare meglio di Commons CLI ... :-)

Dovresti creare il tuo parser della riga di comando Java o utilizzare una libreria?

Molte piccole applicazioni simili a utility probabilmente eseguono il proprio analisi della riga di comando per evitare la dipendenza esterna aggiuntiva. picocli può essere un'alternativa interessante.

Picocli è una libreria e un framework moderni per creare con facilità app da riga di comando potenti, intuitive e compatibili con GraalVM. Vive in 1 file di origine, quindi le app possono includerlo come fonte per evitare l'aggiunta di una dipendenza.

Supporta colori, completamento automatico, sottocomandi e altro. Scritto in Java, utilizzabile da Groovy, Kotlin, Scala, ecc.

Caratteristiche:

• Basato su annotazioni: dichiarativo , evita la duplicazione ed esprime l' intento del programmatore
• Conveniente: analizzare l'input dell'utente ed eseguire la logica aziendale con una riga di codice
• Tutto fortemente tipizzato : opzioni della riga di comando e parametri posizionali
• Opzioni brevi cluster POSIX ( <command> -xvfInputFilenonché <command> -x -v -f InputFile)
• Controllo a grana fine : un modello arity che consente un numero minimo, massimo e variabile di parametri, ad es "1..*"."3..5"
• Sottocomandi (può essere nidificato a profondità arbitraria)
• Ricco di funzionalità : gruppi arg componibili, suddivisione di argomenti quotati, sottocomandi ripetibili e molti altri
• Facile da usare : il messaggio di aiuto per l'uso usa i colori per contrastare elementi importanti come i nomi delle opzioni dal resto dell'aiuto per ridurre il carico cognitivo sull'utente
• Distribuisci la tua app come immagine nativa di GraalVM
• Funziona con Java 5 e versioni successive
• Documentazione ampia e meticolosa

Il messaggio di aiuto per l'uso è facile da personalizzare con le annotazioni (senza programmazione). Per esempio:

( fonte )

Non ho resistito all'aggiunta di uno screenshot in più per mostrare quali messaggi di aiuto sull'utilizzo sono possibili. L'aiuto all'utilizzo è il volto della tua applicazione, quindi sii creativo e divertiti!

Disclaimer: ho creato picocli. Feedback o domande molto gradite.

Ho usato JOpt e l'ho trovato abbastanza utile: http://jopt-simple.sourceforge.net/

La prima pagina fornisce anche un elenco di circa 8 librerie alternative, verificale e scegli quella più adatta alle tue esigenze.

Qualcuno mi ha indicato di recente args4j che si basa sulle annotazioni. Mi piace veramente!

Questa è la libreria di analisi della riga di comando di Google open source come parte del progetto Bazel. Personalmente penso che sia il migliore in circolazione e molto più semplice dell'interfaccia della riga di comando di Apache.

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

Installazione

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'
}

Esperto di

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

uso

Crea una classe che estende OptionsBasee definisce i tuoi @Option.

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;

}

Analizza gli argomenti e usali.

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

Dai un'occhiata al progetto CLI Commons , ci sono un sacco di cose buone lì dentro.

Yeap.

Penso che tu stia cercando qualcosa del genere: http://commons.apache.org/cli

La libreria CLI di Apache Commons fornisce un'API per l'elaborazione delle interfacce della riga di comando.

So che molte persone qui troveranno 10 milioni di motivi per cui non amano la mia strada, ma non importa. Mi piace mantenere le cose semplici, quindi separo la chiave dal valore usando un '=' e le memorizzo in una HashMap in questo modo:

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

Puoi sempre mantenere un elenco con gli argomenti che ti aspetti, per aiutare l'utente nel caso in cui abbia dimenticato un argomento o ne abbia usato uno sbagliato ... Tuttavia, se vuoi troppe funzionalità questa soluzione non fa comunque per te.

Forse questi

• Suite di analisi delle opzioni della riga di comando JArgs per Java : questo piccolo progetto fornisce una suite di parser di opzioni della riga di comando conveniente, compatta, preconfezionata e ampiamente documentata per l'uso dei programmatori Java. Inizialmente, viene fornito l'analisi compatibile con "getopt" in stile GNU.

• ritopt, The Ultimate Options Parser for Java - Sebbene siano stati predisposti diversi standard di opzioni della riga di comando, ritopt segue le convenzioni prescritte nel pacchetto opt.

Potresti trovare questo meta-articolo di infelicità interessante come punto di partenza:

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

Ne ho scritto un altro: http://argparse4j.sourceforge.net/

Argparse4j è una libreria di parser di argomenti della riga di comando per Java, basata sull'argparse di Python.

Se hai familiarità con gnu getopt, c'è una porta Java su: http://www.urbanophile.com/arenn/hacking/download.htm .

Sembra che ci siano alcune classi che lo fanno:

• 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

la compagnia aerea @ Github sembra a posto. Si basa sull'annotazione e sta cercando di emulare le strutture della riga di comando di Git.

Se stai già utilizzando Spring Boot, l'analisi degli argomenti viene fuori dalla scatola.

Se vuoi eseguire qualcosa dopo l'avvio, implementa l' ApplicationRunnerinterfaccia:

@SpringBootApplication
public class Application implements ApplicationRunner {

  public static void main(String[] args) {
    SpringApplication.run(Application.class, args);
  }

  @Override
  public void run(ApplicationArguments args) {
    args.containsOption("my-flag-option"); // test if --my-flag-option was set
    args.getOptionValues("my-option");     // returns values of --my-option=value1 --my-option=value2 
    args.getOptionNames();                 // returns a list of all available options
    // do something with your args
  }
}

Il tuo run metodo verrà invocato dopo che il contesto è stato avviato correttamente.

Se è necessario accedere agli argomenti prima di avviare il contesto dell'applicazione, è possibile semplicemente analizzare manualmente gli argomenti dell'applicazione:

@SpringBootApplication
public class Application implements ApplicationRunner {

  public static void main(String[] args) {
    ApplicationArguments arguments = new DefaultApplicationArguments(args);
    // do whatever you like with your arguments
    // see above ...
    SpringApplication.run(Application.class, args);
  }

}

E infine, se hai bisogno di accedere ai tuoi argomenti in un bean, basta inserire ApplicationArguments:

@Component
public class MyBean {

   @Autowired
   private ApplicationArguments arguments;

   // ...
}

Argparse4j è il migliore che abbia trovato. Imita il libparse argary di Python che è molto conveniente e potente.

Se vuoi qualcosa di leggero (dimensioni del vaso ~ 20 kb) e semplice da usare, puoi provare l' argomento-parser . Può essere utilizzato nella maggior parte dei casi d'uso, supporta la specifica di array nell'argomento e non ha alcuna dipendenza da qualsiasi altra libreria. Funziona con Java 1.5 o versioni successive. Il seguente estratto mostra un esempio su come 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);
}

Altri esempi possono essere trovati qui

Non consiglierei di usare Apache Common CLI libreria, in quanto non è thread-safe.

Utilizza classi stateful con variabili e metodi statici per eseguire lavori interni (ad es. OptionBuilder) E dovrebbe essere usato solo in situazioni fortemente controllate a thread singolo.

Come uno dei commenti menzionati in precedenza ( https://github.com/pcj/google-options ) sarebbe una buona scelta per iniziare.

Una cosa che voglio aggiungere è:

1) Se si verifica un errore di riflessione del parser, provare a utilizzare una versione più recente di guava. nel mio 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) Quando si esegue la riga di comando:

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

3) Quando hai bisogno della guida per l'uso, digita:

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

Per gli utenti di Spring, dovremmo menzionare anche https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/core/env/SimpleCommandLinePropertySource.html e suo fratello gemello https: //docs.spring .io / spring / docs / current / javadoc-api / org / springframework / core / env / JOptCommandLinePropertySource.html (implementazione JOpt della stessa funzionalità). Il vantaggio in Spring è che puoi associare direttamente gli argomenti della riga di comando agli attributi, qui c'è un esempio https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/core/env/ CommandLinePropertySource.html