Jaki jest dobry sposób analizowania argumentów wiersza poleceń w Javie?

Sprawdź te:

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

Lub rzuć własnym:

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

Na przykład w ten sposób commons-clianalizujesz 2 argumenty łańcuchowe:

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

    }

}

użycie z wiersza poleceń:

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

Spójrz na najnowszego JCommandera .

Stworzyłem to. Z przyjemnością otrzymam pytania lub prośby o nowe funkcje.

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

• Linia lotnicza
  • Active Fork: https://github.com/rvesse/airline
• argparse4j
• argparser
• args4j
• clajr
• cli-parser
• CmdLn
• Wiersz poleceń
• DocOpt.java
• delfin getopt
• DPML CLI (widelec Jakarta Commons CLI2)
• Dr Matthias Laux
• Jakarta Commons CLI
• jargo
• jargp
• jargs
• java-getopt
• jbock
• JCLAP
• jcmdline
• dowódca
• jcommando
• jewelcli (napisane przeze mnie)
• JOpt simple
• jsap
• naturalcli
• Artykuł CLI mentora obiektu (więcej o refaktoryzacji i TDD)
• parse-cmd
• ritopt
• Rop
• Polecenie TE-Code
• Picocli ma kolorystykę użytkowania ANSI i funkcję autouzupełniania

Jest rok 2020, czas na lepsze niż Commons CLI ... :-)

Czy należy zbudować własny analizator składni wiersza poleceń Java, czy skorzystać z biblioteki?

Wiele małych aplikacji podobnych do narzędzi prawdopodobnie przetwarza własne parsowanie wiersza poleceń, aby uniknąć dodatkowej zależności zewnętrznej. picocli może być interesującą alternatywą.

Picocli to nowoczesna biblioteka i środowisko do łatwego tworzenia wydajnych, przyjaznych dla użytkownika aplikacji obsługujących GraalVM. Znajduje się w 1 pliku źródłowym, więc aplikacje mogą uwzględnić go jako źródło, aby uniknąć dodawania zależności.

Obsługuje kolory, autouzupełnianie, podkomendy i wiele innych. Napisane w Javie, do użytku z Groovy, Kotlin, Scala itp.

Funkcje:

• Oparte na adnotacjach: deklaratywne , pozwala uniknąć powielania i wyraża zamiary programisty
• Wygodne: przeanalizuj dane wejściowe użytkownika i uruchom logikę biznesową za pomocą jednego wiersza kodu
• Mocno wpisane wszystko - opcje wiersza poleceń, a także parametry pozycyjne
• Klastry krótkie opcje POSIX ( <command> -xvfInputFilea także <command> -x -v -f InputFile)
• Drobnoziarnisty sterowania : model arity który pozwala minimum, maksimum i zmienną liczbę parametrów, na przykład "1..*","3..5"
• Podkomendy (można zagnieżdżać na dowolnej głębokości)
• Bogaty w funkcje : składane grupy argumentów, dzielenie cytowanych argumentów, powtarzalne komendy i wiele innych
• Przyjazny dla użytkownika : komunikat pomocy użytkowania używa kolorów do kontrastowania ważnych elementów, takich jak nazwy opcji z pozostałej części użycia, pomagając zmniejszyć obciążenie poznawcze użytkownika
• Rozpowszechnij swoją aplikację jako natywny obraz GraalVM
• Działa z Javą 5 i nowszymi
• Obszerna i drobiazgowa dokumentacja

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

( źródło )

Nie mogłem się powstrzymać przed dodaniem jeszcze jednego zrzutu ekranu, aby pokazać, jakie komunikaty pomocy dotyczące użytkowania są możliwe. Pomoc dotycząca użytkowania jest obliczem Twojej aplikacji, więc bądź kreatywny i baw się dobrze!

Uwaga: Stworzyłem picocli. Informacje zwrotne lub pytania bardzo mile widziane.

Użyłem JOpt i okazało się, że jest to całkiem przydatne: http://jopt-simple.sourceforge.net/

Na pierwszej stronie znajduje się również lista około 8 alternatywnych bibliotek, sprawdź je i wybierz tę, która najbardziej odpowiada Twoim potrzebom.

Ktoś wskazał mi ostatnio na args4j, który jest oparty na adnotacjach. Naprawdę to lubie!

Jest to biblioteka parsująca Google'a z linii poleceń, otwarta w ramach projektu Bazel. Osobiście uważam, że jest najlepszy i o wiele łatwiejszy niż CLI Apache.

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>

Stosowanie

Utwórz klasę, która rozszerza OptionsBasei 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;

}

Analizuj argumenty i używaj ich.

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 , wiele dobrych rzeczy.

Tak

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

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

Wiem, że większość ludzi znajdzie 10 milionów powodów, dla których nie lubią mojej drogi, ale nieważne. Lubię upraszczać, więc po prostu oddzielam klucz od wartości za pomocą '=' i przechowuję je w HashMap jak poniżej:

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ł o argumentie lub użył niewłaściwego ... Jednak jeśli chcesz mieć zbyt wiele funkcji, to rozwiązanie i tak nie jest dla Ciebie.

Może te

• Pakiet analizujący opcje wiersza poleceń JArgs dla Javy - ten niewielki projekt zapewnia wygodny, kompaktowy, wstępnie spakowany i kompleksowo udokumentowany zestaw analizatorów opcji wiersza poleceń do użytku programistów Java. Początkowo zapewnione jest parsowanie zgodne z „getopt” w stylu GNU.

• ritopt, The Ultimate Parser Options for Java - Chociaż wprowadzono kilka standardów opcji wiersza poleceń, ritopt przestrzega konwencji określonych w pakiecie opt.

Ciekawy może być ten meta artykuł nieszczęścia:

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

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

Argparse4j to biblioteka analizatora argumentów wiersza poleceń dla Java, oparta na argparse Pythona.

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

Wydaje się, że istnieją takie klasy:

• 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

linia lotnicza @ Github wygląda dobrze. Opiera się na adnotacjach i próbuje emulować struktury wiersza poleceń Git.

Jeśli korzystasz już z Spring Boot, parsowanie argumentów wychodzi z pudełka.

Jeśli chcesz uruchomić coś po uruchomieniu, zaimplementuj ApplicationRunnerinterfejs:

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

Twoja runmetoda zostanie wywołana po pomyślnym uruchomieniu kontekstu.

Jeśli potrzebujesz dostępu do argumentów przed uruchomieniem kontekstu aplikacji, możesz po prostu ręcznie przeanalizować argumenty aplikacji:

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

}

I na koniec, jeśli potrzebujesz dostępu do swoich argumentów w fasoli, po prostu wstrzyknij ApplicationArguments:

@Component
public class MyBean {

   @Autowired
   private ApplicationArguments arguments;

   // ...
}

Argparse4j jest najlepszym, jaki znalazłem. Naśladuje on argusową bibliotekę Pythona, która jest bardzo wygodna i potężna.

Jeśli chcesz czegoś lekkiego (rozmiar słoika ~ 20 kb) i prostego w użyciu, możesz wypróbować argument-parser . Może być używany w większości przypadków użycia, obsługuje określanie tablic w argumencie i nie jest zależny od żadnej innej biblioteki. Działa z Javą 1.5 lub nowszą. Poniżej fragment pokazuje przykład, jak go używać:

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

Nie polecam korzystania z Apache Common CLIbiblioteki, ponieważ nie jest ona bezpieczna dla wątków.

Wykorzystuje klasy stanowe ze zmiennymi statycznymi i metodami do wykonywania pracy wewnętrznej (np. OptionBuilder) I powinien być stosowany tylko w ściśle kontrolowanych sytuacjach jednowątkowych.

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

Chcę dodać jedną rzecz:

1) Jeśli wystąpi błąd odbicia parsera, spróbuj użyć nowszej wersji guawy. 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 polecenia:

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

3) Gdy potrzebujesz pomocy dotyczącej użytkowania, po prostu wpisz:

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

Dla użytkowników Springa powinniśmy również wspomnieć o https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/core/env/SimpleCommandLinePropertySource.html i jego bracie bliźniaku https: //docs.spring .io / spring / docs / current / javadoc-api / org / springframework / core / env / JOptCommandLinePropertySource.html (implementacja JOpt tej samej funkcjonalności). Zaletą Spring jest to, że możesz bezpośrednio powiązać argumenty wiersza poleceń z atrybutami, jest tutaj przykład https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/core/env/ CommandLinePropertySource.html