Process the command line with CLI in Java

Writing code to parse command line arguments
isn’t the most exciting job, but sometimes it’s still necessary.
The next time you need to examine command line arguments and things
get a little complex, whip out your trusty open source Java
toolkit, and use Command Line Interface (CLI).

Jakarta Commons hosts the CLI project. While
it’s overkill if you only have one or two arguments, it’s essential
if your application takes most of its settings from the command
line.

To use CLI, you need to create an instance of
the Options class:

Options opt = new Options();

With this instance of Options, you define the
command line arguments that your application will accept. One way
to do this is by using the addOption() method of the Options class.
Call this method once for each option that your application can
accept.

opt.addOption(“h”, false, “Print help for this
application”);
opt.addOption(“u”, true, “The username to use”);
opt.addOption(“dsn”, true, “The data source to use”);

Once you define your classes’ arguments, create
a CommandLineParser, and parse the String array that was passed to
your main method.

BasicParser parser = new BasicParser();
CommandLine cl = parser.parse(opt, args);

Now that all of the arguments are parsed, you
can examine the CommandLine instance returned by the parser to
determine what arguments and values were supplied by the user.

if ( cl.hasOption(‘h’) ) {
    HelpFormatter f = new
HelpFormatter();
    f.printHelp(“OptionsTip”, opt);
}
else {
   
System.out.println(cl.getOptionValue(“u”));
   
System.out.println(cl.getOptionValue(“dsn”));
}

As you can see from above, you can use the
HelpFormatter class to automatically generate usage information for
your program.

Here’s the entire code:

// OptionsTip.java
import org.apache.commons.cli.BasicParser;
import org.apache.commons.cli.Options;
import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.HelpFormatter;
import org.apache.commons.cli.ParseException;

public class OptionsTip {
    public static void main(String args[])
{
        try {
            Options
opt = new Options();

            opt.addOption(“h”,
false, “Print help for this application”);
            opt.addOption(“u”,
true, “The username to use”);
           
opt.addOption(“dsn”, true, “The data source to use”);

            BasicParser
parser = new BasicParser();
            CommandLine
cl = parser.parse(opt, args);

            if
( cl.hasOption(‘h’) ) {
                HelpFormatter
f = new HelpFormatter();
               
f.printHelp(“OptionsTip”, opt);
            }

            else
{
                System.out.println(cl.getOptionValue(“u”));

               
System.out.println(cl.getOptionValue(“dsn”));
            }

        }
        catch
(ParseException e) {
            e.printStackTrace();

        }
    }
}

CLI takes a tedious chore off your hands and
makes parsing command line arguments a simple task. For more
information, check
out the documentation.

Delivered each Thursday, our free Java newsletter provides insight and hands-on tips you need to unlock the full potential of this programming language. Automatically sign up today!