Проверьте это:

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

Или сверните свой собственный:

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

Например, вот как вы используете commons-cli для синтаксического анализа 2 строковых аргументов:

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

    }

}

использование из командной строки:

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

Взгляните на проект Commons CLI, там много хороших вещей.

Может, эти

• Разбор параметров командной строки JArgs набор для Java - этот крошечный проект предоставляет удобный, компактный, предварительно упакованный и всесторонне документированный набор парсеров параметров командной строки для использования программистами Java. Изначально предоставляется синтаксический анализ, совместимый с «getopt» в стиле GNU.

• ritopt, Парсер Ultimate Options для Java - Хотя было предложено несколько стандартов параметров командной строки, ritopt следует соглашениям, предписанным в пакете opt.

Я использовал JOpt, и он мне очень пригодился: http://jopt-simple.sourceforge.net/

На главной странице также представлен список из примерно 8 альтернативных библиотек, просмотрите их и выберите ту, которая больше всего соответствует вашим потребностям.

Ага.

Я думаю, вы ищете что-то вроде этого: http://commons.apache.org/cli

The Apache Commons CLI library provides an API for processing command line interfaces.

Если вы знакомы с gnu getopt, порт Java находится по адресу: http://www.urbanophile.com/arenn/hacking/download.htm.

Кажется, есть несколько классов, которые делают это:

• 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

Кто-то недавно указал мне на args4j, который основан на аннотациях. Мне это и вправду нравится!

Взгляните на более свежий JCommander.

Я создал это. Я буду рад получить вопросы или пожелания.

Я пытался поддерживать список парсеров Java CLI.

• Авиакомпания
  • Активная вилка: https://github.com/rvesse/airline
• argparse4j
• argparser
• args4j
• Clajr
• cli-parser
• CmdLn
• Командная строка
• DocOpt.java
• дельфин
• DPML CLI (вилка Jakarta Commons CLI2)
• Д-р Матиас Ло
• Интерфейс командной строки Jakarta Commons
• жарго
• jargp
• фляги
• java-getopt
• jbock
• JCLAP
• jcmdline
• jcommander
• jcommando
• jewelcli (написано мной)
• JOpt простой
• jsap
• Naturalcli
• Статья Object Mentor CLI (подробнее о рефакторинге и TDD)
• parse-cmd
• ритопт
• Роп
• Команда TE-кода
• пикокли имеет раскрашенную справку по использованию ANSI и автозаполнение

Я написал еще один: http://argparse4j.sourceforge.net/

Argparse4j - это библиотека парсера аргументов командной строки для Java, основанная на Python argparse.

авиакомпания @ Github выглядит хорошо. Он основан на аннотации и пытается имитировать структуры командной строки Git.

Это библиотека синтаксического анализа командной строки Google с открытым исходным кодом в рамках проекта Bazel. Лично я считаю, что это лучший вариант и намного проще, чем Apache CLI.

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

Установка

Базель

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>

использование

Создайте класс, расширяющий OptionsBase и определяющий ваши @Option (ы).

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;

}

Разбирайте аргументы и используйте их.

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

It is 2021, time to do better than Commons CLI... :-)

Следует ли вам создать собственный синтаксический анализатор командной строки Java или использовать библиотеку?

Многие небольшие приложения, подобные служебным программам, вероятно, используют собственный синтаксический анализ командной строки, чтобы избежать дополнительной внешней зависимости. пикокли может быть интересной альтернативой.

Picocli - это современная библиотека и фреймворк для легкого создания мощных, удобных приложений командной строки с поддержкой GraalVM. Он находится в 1 исходном файле, поэтому приложения могут включать его в качестве источника, чтобы избежать добавления зависимости.

Он поддерживает цвета, автозаполнение, подкоманды и многое другое. Написано на Java, может использоваться из Groovy, Kotlin, Scala и т. д.

Функции:

• На основе аннотаций: декларативный, избегает дублирования и выражает программатор намерение
• Удобно: анализируйте вводимые пользователем данные и запускайте бизнес-логику с помощью одна строка кода
• Строго типизированный все - параметры командной строки, а также позиционные параметры
• Кластерные короткие параметры POSIX (<command> -xvfInputFile, а также <command> -x -v -f InputFile)
• Детальный контроль: модель арности, которая допускает минимальное, максимальное и переменное количество параметров, например, "1..*", "3..5"
• Подкоманды (может быть вложен на произвольную глубину)
• Многофункциональный: составные группы аргументов, разделение аргументов в кавычках, повторяемые подкоманды и многое другое
• Удобный: сообщение справки по использованию использует цвета, чтобы противопоставить важные элементы, такие как имена параметров, от остальной части справки по использованию с снизить когнитивную нагрузку для пользователя
• Распространите свое приложение как Собственный образ GraalVM
• Работает с Java 5 и выше
• Обширный и тщательный документация

Справочное сообщение по использованию легко изменить с помощью аннотаций (без программирования). Например:

(источник)

Я не удержался и добавил еще один снимок экрана, чтобы показать, какие справочные сообщения возможны. Помощь в использовании - это лицо вашего приложения, так что будьте изобретательны и получайте удовольствие!

Отказ от ответственности: я создал picocli. Отзывы или вопросы очень приветствуются.

Если вам нужно что-то легкое (размер jar ~ 20 кб) и простое в использовании, вы можете попробовать анализатор аргументов. Он может использоваться в большинстве случаев использования, поддерживает указание массивов в аргументе и не зависит от какой-либо другой библиотеки. Он работает для Java 1.5 или выше. Ниже отрывок показывает пример того, как его использовать:

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

Больше примеров можно найти здесь

Argparse4j - лучшее, что я нашел. Он имитирует библиотеку Python argparse, которая очень удобна и мощна.

Я знаю, что большинство людей здесь найдут 10 миллионов причин, почему им не нравится мой путь, но это не важно. Я предпочитаю, чтобы все было просто, поэтому я просто отделяю ключ от значения с помощью '=' и сохраняю их в HashMap следующим образом:

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

Вы всегда можете вести список с ожидаемыми аргументами, чтобы помочь пользователю в случае, если он забыл аргумент или использовал неправильный ... Однако, если вам нужно слишком много функций, это решение в любом случае не для вас.

Как один из комментариев, упомянутых ранее (https://github.com/pcj/google-options), было бы хорошим выбором для начала.

Одна вещь, которую я хочу добавить:

1) Если вы столкнулись с какой-либо ошибкой отражения парсера, попробуйте использовать более новую версию файла guava. в моем случае:

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) При запуске командной строки:

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

3) Если вам понадобится помощь, просто введите:

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

Для пользователей Spring мы должны упомянуть также https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/core/env/SimpleCommandLinePropertySource.html и его брата-близнеца https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/core/env/JOptCommandLinePropertySource.html (реализация той же функциональности JOpt). Преимущество Spring заключается в том, что вы можете напрямую привязать аргументы командной строки к атрибутам, здесь есть пример https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/core/env/CommandLinePropertySource.html

Если вы уже используете Spring Boot, синтаксический анализ аргументов идет прямо из коробки.

Если вы хотите что-то запустить после запуска, реализуйте интерфейс 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
  }
}

Ваш метод run будет вызван после успешного запуска контекста.

Если вам нужен доступ к аргументам перед, вы запускаете контекст своего приложения, вы можете просто вручную проанализировать аргументы приложения:

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

}

И, наконец, если вам нужен доступ к вашим аргументам в bean-компоненте, просто введите ApplicationArguments:

@Component
public class MyBean {

   @Autowired
   private ApplicationArguments arguments;

   // ...
}

Я хочу показать вам свою реализацию: ReadyCLI

Преимущества:

• для ленивых программистов: очень небольшое количество классов для изучения, просто посмотрите два небольших примера в README в репозитории, и вы уже изучили 90%; просто начните кодировать свой CLI / Parser без каких-либо других знаний; ReadyCLI позволяет наиболее естественным образом кодировать интерфейсы командной строки;
• он разработан с учетом Опыт разработчика; он в основном использует шаблон проектирования Builder и функциональные интерфейсы для лямбда-выражений, что позволяет очень быстро кодировать;
• поддерживает Опции, Флаги и Подкоманды;
• он позволяет анализировать аргументы из командной строки и создавать более сложные и интерактивные интерфейсы командной строки;
• CLI может быть запущен на стандартном вводе-выводе так же легко, как и на любом другом интерфейсе ввода-вывода, таком как сокеты;
• он дает отличную поддержку для документации команд.

Я разработал этот проект, поскольку мне требовались новые функции (параметры, флаг, подкоманды), которые можно было бы использовать в моих проектах самым простым способом.