Question Comment analyser les arguments de la ligne de commande en Java?


Quel est un bon moyen d'analyser les arguments de ligne de commande en Java?


462
2017-12-15 07:46


origine


Réponses:


Vérifiez ces:

Ou roulez le vôtre:


Par exemple, c'est comme ça que tu utilises commons-cli pour analyser 2 arguments de chaîne:

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

    }

}

utilisation depuis la ligne de commande:

$> 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

291
2017-12-15 07:49



Jetez un oeil à la plus récente JCommander.

Je l'ai créé. Je suis heureux de recevoir des questions ou des demandes de fonctionnalités.


279
2017-07-26 16:52



J'ai essayé de maintenir un liste des analyseurs Java CLI.


194
2017-10-20 00:21



J'ai utilisé JOpt et je l'ai trouvé très pratique: http://jopt-simple.sourceforge.net/

La première page fournit également une liste d'environ 8 bibliothèques alternatives, vérifiez-les et choisissez celle qui correspond le mieux à vos besoins.


22
2017-12-15 07:50



Quelqu'un m'a montré args4j dernièrement, qui est basé sur des annotations. J'aime vraiment ça!


19
2017-12-15 18:07



Il s'agit de la bibliothèque d'analyse en ligne de commande de Google, ouverte dans le cadre du projet Bazel. Personnellement, je pense que c'est le meilleur là-bas, et beaucoup plus facile que Apache CLI.

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

Installation

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>

Usage

Créer une classe qui s'étend OptionsBase et définit votre @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;

}

Analyser les arguments et les utiliser.

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


9
2017-12-07 16:13



Jetez un oeil à la Communes CLI projet, beaucoup de bonnes choses là-bas.


8
2017-12-15 07:50



Yeap.

Je pense que vous cherchez quelque chose comme ceci: http://commons.apache.org/cli

La bibliothèque CLI Apache Commons fournit une API pour le traitement des interfaces de ligne de commande.


7
2017-12-15 07:51