Spójrz na nowszy JCommander .

Ja go stworzyłem. Chętnie otrzymuję pytania lub prośby o funkcje.

Próbowałem utrzymać listę parserów Java CLI.

• linia lotnicza
  • Aktywny Widelec: https://github.com/rvesse/airline
• argparse4j
• argparser
• args4j
• clajr
• CLI-parser
• CmdLn
• linia poleceń
• DocOpt.java
• dolphin getopt
• DPML Cli (Jakarta Commons CLI2 widelec)
• Dr Matthias Laux
• Jakarta Commons CLI
• jargo
• jargp
• jargs
• java-getopt
• jbock
• JCLAP
• jcmdline
• jcommander
• jcommando
• jewelcli (written by me)
• JOpt proste
• jsap
• naturalcli
• obiekt Mentor CLI artykuł (więcej o refaktoringu i TDD)
• parse-cmd
• ritopt
• Rop
• TE-Code Command
• picocli ma ANSI kolorową pomoc użytkowania i autouzupełnianie

Użyłem JOpt i uznałem go za całkiem przydatny: http://jopt-simple.sourceforge.net/

Strona główna zawiera również listę około 8 alternatywnych bibliotek, sprawdź je i wybierz tę, która najbardziej odpowiada twoim potrzebom.

Ktoś wskazał mi ostatnio args4j który jest oparty na adnotacji. Bardzo mi się podoba!

Jest to biblioteka parsowania wiersza poleceń Google open-source jako część projektu Bazel. Osobiście uważam, że jest najlepszy na świecie i o wiele łatwiejszy niż Apache CLI.

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

Instalacja

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>

Użycie

Utwórz klasę, która rozszerza OptionsBase i definiuje twoje @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;

}

Przeanalizuj argumenty i użyj oni.

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

Spójrz na projekt Commons CLI , dużo tam dobrych rzeczy.

Maybe these

• picocli "potężny mały interfejs wiersza poleceń" . Picocli jest biblioteką parserów argumentów wiersza poleceń dla Javy-z kolorową pomocą ANSI i uzupełnianiem wiersza poleceń. Na uwagę zasługują również zagnieżdżone podpowiedzi, szczegółowa instrukcja obsługi i możliwość dołączenia jako źródła, aby uniknąć w zależności od słoika picocli.

• Parsowanie opcji linii poleceń JArgs suite for Java - Ten mały projekt zapewnia wygodny, kompaktowy, wstępnie zapakowany i kompleksowo udokumentowany zestaw parserów opcji wiersza poleceń do obsługi programistów Java. Początkowo dostarczane jest parsowanie zgodne z GNU-style 'getopt'.

• Ritopt, ostateczny Parser opcji dla Javy - chociaż kilka standardów opcji linii poleceń zostało wstępnie skonfigurowanych, ritopt stosuje konwencje określone w pakiecie opt.

Yeap.

Myślę, że szukasz czegoś takiego: http://commons.apache.org/cli

Biblioteka Apache Commons CLI zapewnia API do przetwarzania interfejsów wiersza poleceń.

Ten meta-artykuł o nieszczęściu może Cię zainteresować jako punkt wyjścia:

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

Kupić czy zbudować?

Wiele małych aplikacji podobnych do narzędzi prawdopodobnie wykonuje własne parsowanie wiersza poleceń, aby uniknąć dodatkowej zależności zewnętrznej.

Picocli może być interesujące. Jest przeznaczony do włączenia jako źródło jako prostsza alternatywa dla cieniowania słoików w uberjar.

Inną funkcją, która może Ci się spodobać, jest pomoc w użyciu kolorów.

Funkcje parsera:

• adnotacja na podstawie: parsowanie jest jedną linijką kod
• mocno wpisywane wszystko - opcje wiersza poleceń oraz parametry pozycyjne
• POSIX clustered short options (<command> -xvfInputFile oraz <command> -x -v -f InputFile)
• model arity, który pozwala na minimalną, maksymalną i zmienną liczbę parametrów, np., "1..*", "3..5"
• Subkomands (może być zagnieżdżony do dowolnej głębokości)
[22]} Działa z Javą 5 i nowszymi [23]}

Komunikat pomocy w użytkowaniu można łatwo dostosować za pomocą adnotacji (bez programowania). Na przykład:

(źródło)

Nie mogłem się oprzeć dodaniu jeszcze jednego zrzutu ekranu, aby pokazać, jakie wiadomości pomocy użytkowania są możliwe. Pomoc użytkowania jest twarzą Twojej aplikacji, więc bądź kreatywny i baw się dobrze!

Zastrzeżenie: stworzyłem picocli. Opinie lub pytania bardzo mile widziane.

Napisałem kolejny: http://argparse4j.sourceforge.net/

Argparse4j jest biblioteką parserów argumentów wiersza poleceń dla Javy, opartą na argparse Pythona.

Jeśli znasz gnu getopt, istnieje Port Javy pod adresem: http://www.urbanophile.com/arenn/hacking/download.htm .

Wydaje się, że istnieje kilka klas, które to robią:

• 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

/ align = "left" / Linear Opiera się na adnotacji i próbuje emulować struktury wiersza poleceń Git.

Nie polecam korzystania z biblioteki Apache Common CLI, ponieważ nie jest to threadsafe. Używa klas stateful ze statycznymi zmiennymi i metodami do wykonywania pracy wewnętrznej (np. OptionBuilder) i powinna być używana tylko w jednowątkowych, silnie kontrolowanych sytuacjach.

Wiem, że większość ludzi tutaj znajdzie 10 milionów powodów, dla których nie lubią mojego sposobu, ale nieważne. Lubię trzymać rzeczy proste, więc po prostu oddzielam klucz od wartości za pomocą ' = ' i przechowuję je w Hashmapie takim jak:

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

Zawsze możesz utrzymywać listę z argumentami, których oczekujesz, aby pomóc użytkownikowi na wypadek, gdyby zapomniał argumentu lub użył niewłaściwego... Jeśli jednak potrzebujesz zbyt wielu funkcji, To rozwiązanie i tak nie jest dla Ciebie.

Jeśli chcesz czegoś lekkiego (rozmiar jar ~ 20 kb) i prostego w użyciu, możesz spróbować argument-parser. Może być używany w większości przypadków użycia, wspiera określanie tablic w argumencie i nie ma zależności od żadnej innej biblioteki. Działa dla Javy 1.5 lub nowszej. Poniższy fragment pokazuje przykład jak z niego korzystać:

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

Więcej przykładów można znaleźć tutaj

Argparse4j jest najlepszy jaki znalazłem. Naśladuje bibliotekę argparse Pythona, która jest bardzo wygodna i potężna.

Jako jeden z komentarzy wymienionych wcześniej ( https://github.com/pcj/google-options ) byłby dobrym wyborem na początek.

Jedna rzecz, którą chcę dodać to:

1) Jeśli napotkasz jakiś błąd odbicia parsera, spróbuj użyć nowszej wersji guava. w moim przypadku:

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) podczas uruchamiania wiersza poleceń:

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

3) Gdy potrzebujesz pomocy w użyciu, po prostu wpisz:

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

Dla wiosennych użytkowników warto wspomnieć również https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/core/env/SimpleCommandLinePropertySource.html{[2]i jego brat bliźniakhttps://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/core/env/JOptCommandLinePropertySource.html (implementacja JOpt tej samej funkcjonalności). Zaletą Springa jest to, że można bezpośrednio powiązać argumenty wiersza poleceń z atrybutami, jest przykład proszę.https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/core/env/CommandLinePropertySource.html