The technical guide of the command line parser framework in the Java class library
Technical guide to the command line parser framework in the java class library
introduction:
Command line analysis is the basis for developing command line interface (CLI) applications.It allows users to perform the program function by input parameters and options by command lines.In the Java class library, there are many command line parser frameworks to choose from, which can simplify the task of analysis of command lines and provide more powerful functions.This article will introduce several commonly used Java command line parser frameworks and provide corresponding code examples.
1. Apache Commons CLI
Apache Commons Cli is a popular command line parser framework that provides the function of analyzing command line parameters and options.It supports short options (such as "-H") and long options (such as "-Help"), which can define necessary parameters and optional parameters, and process different types of parameter values.
Here are a simple example of using Apache Commons Cli:
import org.apache.commons.cli.*;
public class CommandLineParserExample {
public static void main(String[] args) {
Options options = new Options();
// Definition options
Option Helping = New Option ("H", "Help", FALSE, "Show Help Information");
Option nameOption = New option ("n", "name", true, "specified name");
options.addOption(helpOption);
options.addOption(nameOption);
// Analyze the command line parameters
CommandLineParser parser = new DefaultParser();
try {
CommandLine cmd = parser.parse(options, args);
if (cmd.hasOption("help")) {
// Treatment help options
HelpFormatter formatter = new HelpFormatter();
Formatter.printhelp ("Command Name", Options);
}
if (cmd.hasOption("name")) {
// Treat the name option
String name = cmd.getOptionValue("name");
System.out.println ("Hello," + name + "!"););
}
} catch (ParseException e) {
System.out.println ("The command line parameter analysis fails:" + e.getMessage ());
}
}
}
The above examples define two options: "-s-h" ("-Help's abbreviation) are used to display help information, and" -n "("-name "abbreviation) is used to specify the name.The program will perform the corresponding operation according to the situation of the command line parameters.
2. JCommander
JCOMMANDER is a simple and powerful command line parser framework, which allows defining command line parameters and options by annotations.It provides more concise API and more readable code.
The following is an example of using JCOMMANDER:
import com.beust.jcommander.JCommander;
import com.beust.jcommander.Parameter;
public class CommandLineParserExample {
@Parameter (names = {"-H", "-Help"}, description = "Display help information")
private boolean help;
@Parameter (names = {"-n", "--name"}, description = "Specify Name")
private String name;
public static void main(String[] args) {
CommandLineParserExample example = new CommandLineParserExample();
JCommander jCommander = JCommander.newBuilder()
.addObject(example)
.build();
jCommander.parse(args);
if (example.help) {
jCommander.usage();
}
if (example.name != null) {
System.out.println ("Hello," + Example.name + "!"););
}
}
}
The above example uses the annotation method to define two options, similar to the Apache Commons Cli.JCOMMANDER will perform the corresponding operation according to the situation of the command line parameters.
in conclusion:
This article introduces the command line parser framework in two commonly used Java libraries: Apache Commons Cli and JCOMMANDER.They all provide simple, flexible and powerful command line analysis functions.According to actual needs, choosing a suitable framework can simplify the tasks of the command line analysis and improve development efficiency.
Please note that the above examples are only the purpose of demonstration. In actual use, it may need to be modified and expanded according to specific needs.
