it-swarm.com.de

Wie analysiere ich Befehlszeilenargumente in Java?

Was ist eine gute Methode, um Befehlszeilenargumente in Java zu analysieren?

532
lindelof

Guck dir diese an:

Oder rollen Sie Ihre eigenen:


Zum Beispiel verwenden Sie commons-cli , um 2 Zeichenfolgenargumente zu analysieren:

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

    }

}
_

verwendung von der Kommandozeile:

_$> 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
_
357
Vinko Vrsalovic

Werfen Sie einen Blick auf die neueren JCommander .

Ich habe es geschaffen. Ich freue mich über Fragen oder Funktionswünsche.

299
Cedric Beust
224
lexicalscope

Ich habe JOpt verwendet und fand es recht praktisch: http://jopt-simple.sourceforge.net/

Auf der Titelseite finden Sie außerdem eine Liste mit ca. 8 alternativen Bibliotheken. Schauen Sie sich diese an und wählen Sie diejenige aus, die Ihren Anforderungen am besten entspricht.

22
GaryF

Jemand hat mich in letzter Zeit auf args4j hingewiesen, das auf Anmerkungen basiert. Ich mag es wirklich!

20
André

Kaufen oder bauen?

Viele kleine Utility-ähnliche Anwendungen verwenden wahrscheinlich eine eigene Befehlszeilenanalyse, um die zusätzliche externe Abhängigkeit zu vermeiden.

picocli kann interessant sein. Es soll als Quelle als einfachere Alternative zum Schattieren von Gläsern in ein Überglas aufgenommen werden.

Eine weitere Funktion, die Ihnen vielleicht gefällt, ist die Hilfe zur farbigen Darstellung.

Minimal usage help with ANSI colors

Parser-Funktionen:

  • Anmerkungsbasiert: Das Parsen besteht aus einer Codezeile
  • Stark getippt alles - Befehlszeilenoptionen sowie Positionsparameter
  • POSIX-Clustered-Short-Optionen (<command> -xvfInputFile sowie <command> -x -v -f InputFile)
  • Ein Aritätsmodell, das eine minimale, maximale und variable Anzahl von Parametern erlaubt, z. B. "1..*", "3..5".
  • Unterbefehle (können beliebig tief verschachtelt werden)
  • Funktioniert mit Java 5 und höher

Die Hilfemeldung zur Verwendung kann einfach mit Anmerkungen (ohne Programmierung) angepasst werden. Zum Beispiel:

Extended usage help message ( Quelle )

Ich konnte nicht widerstehen, einen weiteren Screenshot hinzuzufügen, um zu zeigen, welche Hilfemeldungen zur Verwendung möglich sind. Die Hilfe zur Verwendung ist das Gesicht Ihrer Anwendung. Seien Sie also kreativ und haben Sie Spaß!

picocli demo

Haftungsausschluss: Ich habe picocli erstellt. Feedback oder Fragen sehr willkommen.

12
Remko Popma

Dies ist Googles Befehlszeilen-Analysebibliothek, die im Rahmen des Bazel-Projekts als Open-Source-Version bereitgestellt wird. Persönlich denke ich, dass es das beste ist, und es ist weitaus einfacher als 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>

Verwendungszweck

Erstellen Sie eine Klasse, die OptionsBase erweitert und Ihre @Option (s) definiert.

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;

}

Analysieren Sie die Argumente und verwenden Sie sie.

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
Paul

Schauen Sie sich das Commons CLI Projekt an, viele gute Sachen drin.

8
Marc Novakowski

Yeap.

Ich denke, Sie suchen nach so etwas: http://commons.Apache.org/cli

Die Apache Commons CLI-Bibliothek bietet eine API für die Verarbeitung von Befehlszeilenschnittstellen.

8
OscarRyz

Vielleicht diese

  • JArgs Kommandozeilenoptions-Parsing-Suite für Java - Dieses winzige Projekt bietet eine praktische, kompakte, vorgefertigte und umfassend dokumentierte Suite von Kommandozeilenoptions-Parsern für die Verwendung von Java Programmierern. Zunächst wird ein mit 'getopt' im GNU-Stil kompatibles Parsing bereitgestellt.

  • ritopt, Der ultimative Options-Parser für Java - Obwohl mehrere Kommandozeilen-Optionsstandards vorab festgelegt wurden, folgt ritopt den im opt-Paket festgelegten Konventionen.

7
mepcotterell

Vielleicht finden Sie diesen Metaartikel des Unglücks als Ausgangspunkt interessant:

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

6
Alex Miller

Ich habe noch einen geschrieben: http://argparse4j.sourceforge.net/

Argparse4j ist eine Parser-Bibliothek für Befehlszeilenargumente für Java, die auf Pythons Argumenten basiert.

5
5
Ray Tayek

airline @ Github sieht gut aus. Es basiert auf Annotation und versucht, Git-Befehlszeilenstrukturen zu emulieren.

4
cthiebaud

Ich weiß, dass die meisten Leute hier 10 Millionen Gründe finden werden, warum sie meinen Weg nicht mögen, aber egal. Ich halte die Dinge gerne einfach, also trenne ich einfach den Schlüssel mit einem '=' vom Wert und speichere sie in einer HashMap wie dieser:

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

Sie können jederzeit eine Liste mit den erwarteten Argumenten führen, um dem Benutzer zu helfen, falls er ein Argument vergessen oder ein falsches verwendet hat. Wenn Sie jedoch zu viele Funktionen wünschen, ist diese Lösung ohnehin nichts für Sie.

3
John Koumarelas

Argparse4j ist das Beste, was ich gefunden habe. Es ahmt Pythons argparese Bibliothek nach, die sehr praktisch und mächtig ist.

2
Trismegistos

Wenn Sie etwas Leichtes (jar size ~ 20 kb) und einfaches verwenden möchten, können Sie versuchen argument-parser . Es kann in den meisten Anwendungsfällen verwendet werden, unterstützt die Angabe von Arrays im Argument und ist von keiner anderen Bibliothek abhängig. Es funktioniert für Java 1.5 oder höher. Der folgende Auszug zeigt ein Beispiel für die Verwendung:

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

Weitere Beispiele finden Sie hier

2

Ich würde die Verwendung der Apache Common CLI-Bibliothek nicht empfehlen, da sie nicht threadsicher ist. Es verwendet Stateful-Klassen mit statischen Variablen und Methoden für die interne Arbeit (z. B. OptionBuilder) und sollte nur in stark kontrollierten Single-Thread-Situationen verwendet werden.

2
Jakub

Wenn Sie Spring Boot bereits verwenden, ist die Argumentanalyse sofort einsatzbereit.

Wenn Sie nach dem Start etwas ausführen möchten, implementieren Sie die Schnittstelle ApplicationRunner:

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

Ihre run -Methode wird aufgerufen, nachdem der Kontext erfolgreich gestartet wurde.

Wenn Sie Zugriff auf die Argumente benötigen vor Sie starten Ihren Anwendungskontext, können Sie die Anwendungsargumente einfach manuell analysieren:

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

}

Und schließlich, wenn Sie Zugriff auf Ihre Argumente in einem Bean benötigen, fügen Sie einfach das ApplicationArguments ein:

@Component
public class MyBean {

   @Autowired
   private ApplicationArguments arguments;

   // ...
}
1
Stefan Haberl

Wie einer der zuvor erwähnten Kommentare ( https://github.com/pcj/google-options ) wäre eine gute Wahl, um damit zu beginnen.

Eine Sache, die ich hinzufügen möchte, ist:

1) Wenn Sie auf einen Parser-Reflektionsfehler stoßen, versuchen Sie bitte, eine neuere Version der Guave zu verwenden. in meinem Fall:

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) Beim Ausführen der Kommandozeile:

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

3) Wenn Sie Hilfe zur Verwendung benötigen, geben Sie einfach Folgendes ein:

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