regardez le plus récent JCommander .

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

j'ai essayé de maintenir une liste de Java cliversers .

• compagnie aérienne
  • fourche Active: https://github.com/rvesse/airline
• argparse4j
• argparser
• args4j
• clajr
• cli-analyseur
• CmdLn
• ligne de commande
• DocOpt.java
• dolphin getopt
• DPML CLI (Jakarta Commons CLI2 fork)
• Dr. Matthias Laux
• Jakarta Commons CLI
• jargo
• jargp
• jargs
• java-getopt
• jbock
• JCLAP
• jcmdline
• jcommander
• jcommando
• jewelcli (écrit par moi)
• JOpt simple
• jsap
• naturalcli
• objet Mentor CLI article (en savoir plus sur refactoring et TDD)
• parse-cmd
• ritopt
• Rop
• TE Commande-Code
• picocli ANSI a colorisée de l'utilisation de l'aide et de saisie semi-automatique

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

la page d'accueil 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 pointé vers args4j dernièrement qui est basé sur l'annotation. Je l'aime vraiment!

C'est la bibliothèque d'analyse en ligne de commande de Google open-sourcing 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

avec les sections de 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>

L'utilisation de la

créer une classe qui é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;

}

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

regardez le projet Commons CLI , plein de bonnes choses là-dedans.

peut-être ces

• picocli "un grand minuscules interface de ligne de commande" . Picocli est une bibliothèque d'analyseur d'arguments en ligne de commande pour Java - avec une aide d'utilisation colorée ANSI et l'achèvement de la ligne de commande. Les sous-commandes imbriquées, le manuel d'utilisation détaillé et la capacité d'inclure comme source à éviter dépendent du pot de picocli sont également remarquables.

• jargon option de ligne de commande suite pour Java -ce petit projet fournit une suite pratique, compacte, pré-emballée et documentée en détail des analyseurs d'options en ligne de commande pour l'utilisation de programmeurs Java. Au départ, un parsing compatible avec le style GNU 'getopt' est fourni.

• ritopt, L'Analyseur D'Options ultime pour Java - bien que plusieurs standards d'options en ligne de commande aient été préprogrammés, ritopt suit les conventions prescrites dans les opt paquet.

Yeap.

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.

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

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

acheter ou construire?

beaucoup de petites applications de type utilitaire roulent probablement leur propre parsing en ligne de commande pour éviter la dépendance externe supplémentaire.

picocli peut être intéressant. Il est conçu pour être inclus comme source comme une alternative plus simple à l'ombrage des pots dans un uberjar.

une autre caractéristique que vous pouvez aimer est son aide d'utilisation colorisée.

caractéristiques de L'Analyseur:

• Annotation de base: l'analyse est une ligne de code
• fortement tapé tout-options de ligne de commande ainsi que les paramètres de position
• POSIX cluster options courtes ( <command> -xvfInputFile ainsi que <command> -x -v -f InputFile )
• un modèle arity qui permet un nombre minimum, maximum et variable de paramètres, E. g, "1..*" , "3..5"
• sous-commandes (pouvant être imbriquées à une profondeur arbitraire)
• fonctionne avec Java 5 et plus

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

( source )

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

avertissement: j'ai créé picocli. Des commentaires ou des questions très bienvenue.

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 argparse de Python.

si vous connaissez gnu getopt, il y a un port Java à: http://www.urbanophile.com/arenn/hacking/download.htm .

il semble y avoir un certain nombre de 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

compagnie aérienne @ Github semble bon. Il est basé sur l'annotation et essaie d'émuler les structures de la ligne de commande Git.

Je ne recommande pas L'utilisation de la bibliothèque CLI commune D'Apache, car elle est non-threadsafe. Il utilise des classes stateful avec des variables statiques et des méthodes pour effectuer le travail interne (par exemple OptionBuilder) et ne doit être utilisé que dans des situations à filetage simple fortement contrôlé.

je sais que la plupart des gens ici vont trouver 10 millions de raisons pour lesquelles ils n'aiment pas ma façon, mais peu importe. J'aime garder les choses simples, donc je sépare juste la clé de la valeur en utilisant un ' = 'et les stocker dans une 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 attendiez, pour aider l'utilisateur dans le cas où il a oublié un argument ou un mauvais... Cependant, si vous voulez trop de fonctionnalités Cette solution n'est pas pour vous de toute façon.

si vous voulez quelque chose de léger (jar size ~ 20 kb) et simple à utiliser, vous pouvez essayer argument-parser . Il peut être utilisé dans la plupart des cas d'utilisation, prend en charge la spécification des tableaux dans l'argument et n'a aucune dépendance sur une autre bibliothèque. Il fonctionne pour Java 1.5 ou plus. Ci-dessous extrait 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);
}

D'autres exemples peuvent être trouvés ici

Argparse4j est le meilleur que j'ai trouvé. Il imite argparse libary de Python qui est très pratique et puissant.

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, s'il vous plaît essayer d'utiliser une nouvelle version 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'utilisation aide, tapez juste:

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

pour les utilisateurs de ressorts, il faut mentionner aussi 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 (JOpt implementation of the same functionality). L'avantage au printemps est que vous pouvez lier directement la ligne de commande arguments aux attributs, il y a un exemple ici https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/core/env/CommandLinePropertySource.html