Парсинг аргументов командной строки в Java: эффективные методы

public static void main(String[] args) {
// Позиционные аргументы
if (args.length > 0) {
String inputFile = args[0];
System.out.println("Input file: " + inputFile);
}

// Поиск флага
boolean verbose = false;
for (String arg : args) {
if (arg.equals("-v") || arg.equals("--verbose")) {
verbose = true;
break;
}
}

if (verbose) {
System.out.println("Verbose mode enabled");
}

// Поиск параметра с значением
String outputFile = "output.txt"; // Значение по умолчанию
for (int i = 0; i < args.length – 1; i++) {
if (args[i].equals("-o") || args[i].equals("--output")) {
outputFile = args[i + 1];
break;
}
}

System.out.println("Output file: " + outputFile);
}

<!-- Maven -->
<dependency>
<groupId>commons-cli</groupId>
<artifactId>commons-cli</artifactId>
<version>1.5.0</version>
</dependency>

// Gradle
implementation 'commons-cli:commons-cli:1.5.0'

import org.apache.commons.cli.*;

public class CliDemo {
public static void main(String[] args) {
// Определение опций
Options options = new Options();

// Простой флаг без значения
options.addOption("v", "verbose", false, "Включить подробный вывод");

// Опция с обязательным значением
options.addOption(Option.builder("i")
.longOpt("input")
.hasArg()
.required()
.desc("Входной файл")
.build());

// Опция с необязательным значением и значением по умолчанию
options.addOption(Option.builder("o")
.longOpt("output")
.hasArg()
.desc("Выходной файл (по умолчанию: output.txt)")
.build());

// Опция с несколькими значениями
options.addOption(Option.builder("f")
.longOpt("filters")
.hasArgs()
.valueSeparator(',')
.desc("Фильтры, разделенные запятыми")
.build());

try {
// Парсинг аргументов
CommandLineParser parser = new DefaultParser();
CommandLine cmd = parser.parse(options, args);

// Извлечение значений
boolean verbose = cmd.hasOption("verbose");
String inputFile = cmd.getOptionValue("input");
String outputFile = cmd.getOptionValue("output", "output.txt");
String[] filters = cmd.getOptionValues("filters");

// Вывод значений
System.out.println("Verbose: " + verbose);
System.out.println("Input file: " + inputFile);
System.out.println("Output file: " + outputFile);

if (filters != null) {
System.out.println("Filters:");
for (String filter : filters) {
System.out.println(" – " + filter);
}
}
} catch (ParseException e) {
// Обработка ошибок парсинга
System.err.println("Error: " + e.getMessage());

// Вывод справки
HelpFormatter formatter = new HelpFormatter();
formatter.printHelp("java CliDemo", options);
System.exit(1);
}
}
}

java CliDemo -i input.dat -o result.csv -v -f filter1,filter2,filter3

<!-- Maven -->
<dependency>
<groupId>com.beust</groupId>
<artifactId>jcommander</artifactId>
<version>1.82</version>
</dependency>

// Gradle
implementation 'com.beust:jcommander:1.82'

import com.beust.jcommander.JCommander;
import com.beust.jcommander.Parameter;
import com.beust.jcommander.ParameterException;

import java.util.ArrayList;
import java.util.List;

public class JCommanderDemo {
@Parameter(names = {"-v", "--verbose"}, description = "Включить подробный вывод")
private boolean verbose = false;

@Parameter(names = {"-i", "--input"}, description = "Входной файл", required = true)
private String inputFile;

@Parameter(names = {"-o", "--output"}, description = "Выходной файл")
private String outputFile = "output.txt";

@Parameter(names = {"-f", "--filters"}, description = "Фильтры", variableArity = true)
private List<String> filters = new ArrayList<>();

@Parameter(names = {"--help"}, help = true, description = "Показать справку")
private boolean help;

public static void main(String[] args) {
JCommanderDemo app = new JCommanderDemo();
JCommander jc = JCommander.newBuilder()
.addObject(app)
.build();

try {
jc.parse(args);

if (app.help) {
jc.usage();
return;
}

app.run();
} catch (ParameterException e) {
System.err.println("Error: " + e.getMessage());
jc.usage();
System.exit(1);
}
}

private void run() {
System.out.println("Verbose: " + verbose);
System.out.println("Input file: " + inputFile);
System.out.println("Output file: " + outputFile);

if (!filters.isEmpty()) {
System.out.println("Filters:");
for (String filter : filters) {
System.out.println(" – " + filter);
}
}
}
}

import com.beust.jcommander.JCommander;
import com.beust.jcommander.Parameter;
import com.beust.jcommander.Parameters;

public class SubCommandDemo {
@Parameter(names = "--debug", description = "Режим отладки")
private boolean debug = false;

public static void main(String[] args) {
SubCommandDemo main = new SubCommandDemo();
CloneCommand cloneCmd = new CloneCommand();
CommitCommand commitCmd = new CommitCommand();

JCommander jc = JCommander.newBuilder()
.addObject(main)
.addCommand("clone", cloneCmd)
.addCommand("commit", commitCmd)
.build();

jc.parse(args);

String command = jc.getParsedCommand();
if (command == null) {
jc.usage();
return;
}

System.out.println("Debug mode: " + main.debug);

if ("clone".equals(command)) {
cloneCmd.run();
} else if ("commit".equals(command)) {
commitCmd.run();
}
}

@Parameters(commandDescription = "Клонировать репозиторий")
public static class CloneCommand {
@Parameter(names = "--url", description = "URL репозитория", required = true)
private String url;

@Parameter(names = "--depth", description = "Глубина клонирования")
private int depth = 1;

public void run() {
System.out.println("Cloning from " + url + " with depth " + depth);
}
}

@Parameters(commandDescription = "Сделать коммит")
public static class CommitCommand {
@Parameter(names = "--message", description = "Сообщение коммита", required = true)
private String message;

@Parameter(names = "--all", description = "Добавить все изменения")
private boolean all = false;

public void run() {
System.out.println("Committing with message: " + message);
System.out.println("Including all changes: " + all);
}
}
}

<!-- Maven -->
<dependency>
<groupId>info.picocli</groupId>
<artifactId>picocli</artifactId>
<version>4.7.0</version>
</dependency>

// Gradle
implementation 'info.picocli:picocli:4.7.0'

import picocli.CommandLine;
import picocli.CommandLine.Command;
import picocli.CommandLine.Option;
import picocli.CommandLine.Parameters;

import java.io.File;
import java.util.List;
import java.util.concurrent.Callable;

@Command(name = "myapp", 
description = "Пример приложения с Picocli",
mixinStandardHelpOptions = true, // Добавляет опции --help и --version
version = "1.0")
public class PicocliDemo implements Callable<Integer> {

@Option(names = {"-v", "--verbose"}, 
description = "Включить подробный вывод")
private boolean verbose;

@Option(names = {"-i", "--input"}, 
description = "Входной файл", 
required = true,
paramLabel = "FILE")
private File inputFile;

@Option(names = {"-o", "--output"}, 
description = "Выходной файл (по умолчанию: ${DEFAULT-VALUE})",
paramLabel = "FILE")
private File outputFile = new File("output.txt");

@Option(names = {"-f", "--filters"}, 
description = "Фильтры для применения",
split = ",")
private List<String> filters;

@Option(names = {"-n", "--count"}, 
description = "Количество итераций (диапазон: ${min}-${max})",
showDefaultValue = CommandLine.Help.Visibility.ALWAYS,
defaultValue = "1")
private int count;

@Parameters(arity = "0..*", 
paramLabel = "FILES",
description = "Дополнительные файлы для обработки")
private List<File> additionalFiles;

@Override
public Integer call() {
// Бизнес-логика приложения
System.out.println("Running with options:");
System.out.println(" Verbose: " + verbose);
System.out.println(" Input file: " + inputFile);
System.out.println(" Output file: " + outputFile);
System.out.println(" Count: " + count);

if (filters != null && !filters.isEmpty()) {
System.out.println(" Filters:");
for (String filter : filters) {
System.out.println(" – " + filter);
}
}

if (additionalFiles != null && !additionalFiles.isEmpty()) {
System.out.println(" Additional files:");
for (File file : additionalFiles) {
System.out.println(" – " + file);
}
}

return 0; // Код возврата
}

public static void main(String[] args) {
int exitCode = new CommandLine(new PicocliDemo()).execute(args);
System.exit(exitCode);
}
}

java PicocliDemo -i input.dat -o output.csv -v -f filter1,filter2 -n 5 extra1.txt extra2.txt
java PicocliDemo -i input.dat --help

import picocli.CommandLine;
import picocli.CommandLine.Command;
import picocli.CommandLine.Option;
import picocli.CommandLine.ParentCommand;

import java.util.concurrent.Callable;

@Command(name = "git", 
description = "Система контроля версий",
subcommands = {GitClone.class, GitCommit.class})
public class GitDemo implements Callable<Integer> {
@Option(names = {"-v", "--verbose"}, description = "Подробный вывод")
private boolean verbose;

@Override
public Integer call() {
System.out.println("Выполните команду: git [clone|commit]");
return 0;
}

public boolean isVerbose() {
return verbose;
}

public static void main(String[] args) {
int exitCode = new CommandLine(new GitDemo()).execute(args);
System.exit(exitCode);
}
}

@Command(name = "clone", description = "Клонировать репозиторий")
class GitClone implements Callable<Integer> {
@ParentCommand
private GitDemo parent;

@Option(names = {"--url"}, required = true, description = "URL репозитория")
private String url;

@Option(names = {"--depth"}, description = "Глубина клонирования")
private int depth = 1;

@Override
public Integer call() {
if (parent.isVerbose()) {
System.out.println("Режим подробного вывода включен");
}
System.out.println("Клонирование из " + url + " с глубиной " + depth);
return 0;
}
}

@Command(name = "commit", description = "Сделать коммит")
class GitCommit implements Callable<Integer> {
@ParentCommand
private GitDemo parent;

@Option(names = {"-m", "--message"}, required = true, description = "Сообщение коммита")
private String message;

@Option(names = {"-a", "--all"}, description = "Добавить все изменения")
private boolean all = false;

@Override
public Integer call() {
if (parent.isVerbose()) {
System.out.println("Режим подробного вывода включен");
}
System.out.println("Коммит с сообщением: " + message);
System.out.println("Добавление всех изменений: " + all);
return 0;
}
}