Quelle est la bonne façon d'analyser les arguments de ligne de commande en Java?

Découvrez-les:

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

Ou lancez le vôtre:

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

Par exemple, voici comment vous utilisez commons-clipour 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

Jetez un œil au JCommander le plus récent .

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

J'ai essayé de maintenir une liste d'analyseurs Java CLI .

• Compagnie aérienne
  • Active Fork: https://github.com/rvesse/airline
• argparse4j
• argparser
• args4j
• clajr
• cli-parser
• CmdLn
• Ligne de commande
• DocOpt.java
• getopt de dauphin
• DPML CLI (Jakarta Commons CLI2 fork)
• Dr. Matthias Laux
• CLI de Jakarta Commons
• Jargo
• jargp
• jargs
• java-getopt
• jbock
• JCLAP
• jcmdline
• jcommander
• jcommando
• jewelcli (écrit par moi)
• JOpt simple
• jsap
• naturalcli
• Article Object Mentor CLI (plus sur le refactoring et TDD)
• parse-cmd
• ritopt
• Rop
• Commande TE-Code
• picocli a une aide à l'utilisation colorisée ANSI et une saisie semi-automatique

Il est 2020, il est temps de faire mieux que Commons CLI ... :-)

Devriez-vous créer votre propre analyseur de ligne de commande Java ou utiliser une bibliothèque?

De nombreuses petites applications de type utilitaire exécutent probablement leur propre analyse en ligne de commande pour éviter la dépendance externe supplémentaire. picocli peut être une alternative intéressante.

Picocli est une bibliothèque et un cadre modernes permettant de créer facilement des applications de ligne de commande GraalVM puissantes et conviviales. Il vit dans 1 fichier source afin que les applications puissent l'inclure comme source pour éviter d'ajouter une dépendance.

Il prend en charge les couleurs, la saisie semi-automatique, les sous-commandes, etc. Écrit en Java, utilisable depuis Groovy, Kotlin, Scala, etc.

Fonctionnalités:

• Basé sur les annotations: déclaratif , évite la duplication et exprime l' intention du programmeur
• Pratique: analysez les entrées utilisateur et exécutez votre logique métier avec une seule ligne de code
• Tout fortement saisi - options de ligne de commande ainsi que paramètres de position
• Options courtes en cluster POSIX ( <command> -xvfInputFileainsi que <command> -x -v -f InputFile)
• Contrôle à grain fin : un modèle d'arité qui permet un nombre minimum, maximum et variable de paramètres, par exemple "1..*","3..5"
• Sous-commandes (peuvent être imbriquées à une profondeur arbitraire)
• Riche en fonctionnalités : groupes d'arguments composables, division d'arguments entre guillemets, sous-commandes répétables et bien d'autres
• Convivial : le message d'aide à l'utilisation utilise des couleurs pour contraster des éléments importants tels que les noms d'options du reste de l'aide à l'utilisation pour réduire la charge cognitive de l'utilisateur
• Distribuez votre application en tant qu'image native GraalVM
• Fonctionne avec Java 5 et supérieur
• Documentation complète et minutieuse

Le message d'aide à l'utilisation est facile à personnaliser avec des annotations (sans programmation). Par exemple:

( source )

Je n'ai pas pu résister à l'ajout d'une capture d'écran supplémentaire pour montrer quels messages d'aide à l'utilisation sont possibles. L'aide à l'utilisation est le visage de votre application, alors soyez créatif et amusez-vous!

Avertissement: j'ai créé picocli. Commentaires ou questions très bienvenus.

J'ai utilisé JOpt et l'ai trouvé assez 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 convient le mieux à vos besoins.

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

Il s'agit de la bibliothèque d'analyse de ligne de commande de Google open source dans le cadre du projet Bazel. Personnellement, je pense que c'est le meilleur, 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éez une classe qui étend OptionsBaseet définit votre @Option( vos ).

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;

}

Analysez les arguments et utilisez-les.

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

Jetez un œil au projet CLI de Commons , plein de bonnes choses là-dedans.

Ouais.

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

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

Je sais que la plupart des gens ici vont trouver 10 millions de raisons pour lesquelles ils n'aiment pas mon chemin, mais peu importe. J'aime garder les choses simples, donc je sépare juste la clé de la valeur en utilisant un '=' et je les stocke dans un HashMap comme ceci:

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

Vous pouvez toujours maintenir une liste avec les arguments que vous attendez, pour aider l'utilisateur au cas où il aurait oublié un argument ou en aurait utilisé un mauvais ... Cependant, si vous voulez trop de fonctionnalités, cette solution n'est pas pour vous de toute façon.

Peut-être que ces

• Suite d'analyse des options de ligne de commande JArgs pour Java - ce petit projet fournit une suite d'analyseurs d'options de ligne de commande pratique, compacte, préemballée et entièrement documentée à l'usage des programmeurs Java. Initialement, l'analyse syntaxique compatible avec «getopt» de style GNU est fournie.

• ritopt, l'analyseur d'options ultime pour Java - Bien que plusieurs normes d'options de ligne de commande aient été proposées, ritopt suit les conventions prescrites dans le package opt.

Vous pourriez trouver ce méta-article de malheur intéressant comme point de départ:

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

J'en ai écrit un autre: http://argparse4j.sourceforge.net/

Argparse4j est une bibliothèque d'analyseur d'arguments en ligne de commande pour Java, basée sur l'argparse de Python.

Si vous connaissez gnu getopt, il existe un port Java sur: http://www.urbanophile.com/arenn/hacking/download.htm .

Il semble y avoir quelques classes qui font cela:

• 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 compagnie aérienne @ Github a l' air bien. Il est basé sur des annotations et tente d'émuler les structures de ligne de commande Git.

Si vous utilisez déjà Spring Boot, l'analyse des arguments sort de la boîte.

Si vous souhaitez exécuter quelque chose après le démarrage, implémentez l' ApplicationRunnerinterface:

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

Votre runméthode sera invoquée après le démarrage réussi du contexte.

Si vous avez besoin d'accéder aux arguments avant de lancer votre contexte d'application, vous pouvez simplement analyser manuellement les arguments d'application:

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

}

Et enfin, si vous avez besoin d'accéder à vos arguments dans un bean, injectez simplement ApplicationArguments:

@Component
public class MyBean {

   @Autowired
   private ApplicationArguments arguments;

   // ...
}

Argparse4j est le meilleur que j'ai trouvé. Il imite la bibliothèque d'argparse de Python qui est très pratique et puissante.

Si vous voulez quelque chose de léger (taille du pot ~ 20 ko) et simple à utiliser, vous pouvez essayer l' analyseur d'arguments . Il peut être utilisé dans la plupart des cas d'utilisation, prend en charge la spécification de tableaux dans l'argument et ne dépend d'aucune autre bibliothèque. Cela fonctionne pour Java 1.5 ou supérieur. L'extrait ci-dessous montre un exemple sur la façon de l'utiliser:

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

Plus d'exemples peuvent être trouvés ici

Je ne recommanderais pas d'utiliser la Apache Common CLIbibliothèque, car elle n'est pas sûre pour les threads.

Il utilise des classes avec état avec des variables statiques et des méthodes pour effectuer un travail interne (par exemple OptionBuilder) et ne doit être utilisé que dans des situations à contrôle unique à thread unique.

Comme l'un des commentaires mentionnés précédemment ( https://github.com/pcj/google-options ) serait un bon choix pour commencer.

Une chose que je veux ajouter est:

1) Si vous rencontrez une erreur de réflexion de l'analyseur, essayez d'utiliser une version plus récente de la goyave. dans mon cas:

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) Lors de l'exécution de la ligne de commande:

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

3) Lorsque vous avez besoin de l'aide à l'utilisation, tapez simplement:

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

Pour les utilisateurs de Spring, nous devons également mentionner https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/core/env/SimpleCommandLinePropertySource.html et son frère jumeau https: //docs.spring .io / spring / docs / current / javadoc-api / org / springframework / core / env / JOptCommandLinePropertySource.html (implémentation JOpt de la même fonctionnalité). L'avantage de Spring est que vous pouvez lier directement les arguments de la ligne de commande aux attributs, il y a un exemple ici https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/core/env/ CommandLinePropertySource.html