JCommander(命令行参数解析工具）

Commander是一个用于解析命令行参数的Java框架，支持解析所有基本的数据类型，也支持将命令行解析成用户自定义的类型，只需要写一个转变函数。

1. JCommander用法

将用来表示参数的fields用@Parameter标识：

 

import com.beust.jcommander.Parameter;

public class JCommanderExample {
  @Parameter
  private List<String> parameters = new ArrayList<String>();

  @Parameter(names = { "-log", "-verbose" }, description = "Level of verbosity")
  private Integer verbose = 1;

  @Parameter(names = "-groups", description = "Comma-separated list of group names to be run")
  private String groups;

  @Parameter(names = "-debug", description = "Debug mode")
  private boolean debug = false;
}

JCommander就可以解析命令行中的参数了：

 

 

JCommanderExample jct = new JCommanderExample();
String[] argv = { "-log", "2", "-groups", "unit" };
new JCommander(jct, argv);

Assert.assertEquals(jct.verbose.intValue(), 2);

 

2. 选项类型

Boolean：

 

@Parameter(names = "-debug", description = "Debug mode", arity = 1)
private boolean debug = true;

boolean类型默认arity=0，这样的话不要用户为参数设置value，只要参数中有-debug就被parse成true，没有就parse成false。但是如果加上 arity=1，则需要用户明确指定value：

 

 

program -debug true
program -debug false

String，Interger，Long：

 

对这几种类型，JCommander会尝试parse随后的参数，并上溯成参数的类型，如果参数不能成功上溯则会产生exception

 

@Parameter(names = "-log", description = "Level of verbosity")
private Integer verbose = 1;

java Main -log 3
//got exception for the following one
java Main -log text

Lists:

 

如果类型是List，则这个参数可出现多次

 

@Parameter(names = "-host", description = "The host")
private List<String> hosts = new ArrayList<String>();

下例中fields hosts包含了两个字符串

 

 

java Main -host host1 -verbose -host host2

Password：

 

指明password为true表明这个field是password，我们不想他出现在命令行上，遇到password的参数，用户会被要求在prompt中输入密码

 

public class ArgsPassword {
  @Parameter(names = "-password", description = "Connection password", password = true)
  private String password;
}

Echo Input：

 

当你想让password显示在prompt中时，需要设置echoInput=true，这个setting只有在password=true时才有效

 

public class ArgsPassword {
  @Parameter(names = "-password", description = "Connection password", password = true, echoInput = true)
  private String password;
}

 

 

3. 自定义类型

当需要更负责的参数时，比如files，host names，lists等，我们可以写一个转换器（converter）来将参数转换成我们想要的格式或类型。转换器需要实现IStringConverter接口

 

public interface IStringConverter<T> {
  T convert(String value);
}

 

a. 通过annotation实现：

下面的converter将string转换成file

 

public class FileConverter implements IStringConverter<File> {
  @Override
  public File convert(String value) {
    return new File(value);
  }
}

将参数对应的field定义成下面这样，注意要在annotation里指定converter

 

 

@Parameter(names = "-file", converter = FileConverter.class)
File file;

b. 通过工厂 factory 实现：

 

在每个parameter annotation中都指定converter有点烦，可以通过factory解决这个问题。

比如你要将下面的参数解析成host和port java App -target example.com:8080
定义一个类来放参数

 

public class HostPort {
  private String host;
  private Integer port;
}

写个converter把参数String转换成HostPort

 

 

class HostPortConverter implements IStringConverter<HostPort> {
  @Override
  public HostPort convert(String value) {
    HostPort result = new HostPort();
    String[] s = value.split(":");
    result.host = s[0];
    result.port = Integer.parseInt(s[1]);

    return result;
  }
}

写一个Factory，作用是返回converter

 

 

public class Factory implements IStringConverterFactory {
  public Class<? extends IStringConverter<?>> getConverter(Class forType) {
    if (forType.equals(HostPort.class)) return HostPortConverter.class;
    else return null;
  }

参数类也很简单，参数类型直接用HostPort就好了

 

 

public class ArgsConverterFactory {
  @Parameter(names = "-hostport")
  private HostPort hostPort;
}

没有看到Factory用在什么地方？是在你的程序创建JCommander时传进去的

 

 

ArgsConverterFactory a = new ArgsConverterFactory();
JCommander jc = new JCommander(a);
jc.addConverterFactory(new Factory());
jc.parse("-hostport", "example.com:8080");

Assert.assertEquals(a.hostPort.host, "example.com");
Assert.assertEquals(a.hostPort.port.intValue(), 8080);

4. 参数验证
通过提供一个实现了IParameterValidator接口的类，可以让JCommander验证你的参数

 

 

public interface IParameterValidator {
 /**
   * Validate the parameter.
   *
   * @param name The name of the parameter (e.g. "-host").
   * @param value The value of the parameter that we need to validate
   *
   * @throws ParameterException Thrown if the value of the parameter is invalid.
   */
  void validate(String name, String value) throws ParameterException;
}

下面这个validator可以验证提供的参数为正整数

 

 

public class PositiveInteger implements IParameterValidator {
 public void validate(String name, String value)
      throws ParameterException {
    int n = Integer.parseInt(value);
    if (n < 0) {
      throw new ParameterException("Parameter " + name + " should be positive (found " + value +")");
    }
  }
}

在parameter annotation中用validateWith来指定验证器

 

 

@Parameter(names = "-age", validateWith = PositiveInteger.class)
private Integer age;

 

 

 

5. 主参数

我们可以定义一个main parameter来放所有参数，这个参数不用指定names，必须为List<String>类型

 

@Parameter(description = "Files")
private List<String> files = new ArrayList<String>();

@Parameter(names = "-debug", description = "Debugging level")
private Integer debug = 1;

run下面命令行，files会保存‘file1’和‘file2’

 

 

java Main -debug file1 file2

6. 私有参数

 

参数可以是private的

 

public class ArgsPrivate {
  @Parameter(names = "-verbose")
  private Integer verbose = 1;

  public Integer getVerbose() {
    return verbose;
  }
}

 

 

ArgsPrivate args = new ArgsPrivate();
new JCommander(args, "-verbose", "3");
Assert.assertEquals(args.getVerbose().intValue(), 3);

7. 参数分隔符

参数默认用空格分隔，但是我们也可以指定自己的分隔符，比如用“：”， “=”等，java Main -log:3
可以在参数类定义中使用@Parameter annotation指定分隔符

 

@Parameters(separators = "=")
public class SeparatorEqual {
  @Parameter(names = "-level")
  private Integer level = 2;
}

 

8. 多重描述（多个参数类）

你可以将参数放在不同的参数类中，比如定义以下两个含有不同参数的参数类

 

public class ArgsMaster {
  @Parameter(names = "-master")
  private String master;
}

public class ArgsSlave {
  @Parameter(names = "-slave")
  private String slave;
}

使用时将两个类都传入JCommander

 

 

ArgsMaster m = new ArgsMaster();
ArgsSlave s = new ArgsSlave();
String[] argv = { "-master", "master", "-slave", "slave" };
new JCommander(new Object[] { m , s }, argv);

Assert.assertEquals(m.master, "master");
Assert.assertEquals(s.slave, "slave");

9. @语法

 

JCommander支持从文件中获取并解析参数，比如文件/tmp/params中包含了以下内容

 

-verbose
file1
file2
file3

在命令行中用@指定文件路径即可

 

 

java Main @/tmp/parameters

10. 参数value数量（Arities）

 

有时候你想为一个参数设置多个值，这时就要用到arity，比如-pairs需要两个values，则设置arity=2

 

@Parameter(names = "-pairs", arity = 2, description = "Pairs")
private List<String> pairs;

JCommander就会为pairs接收两个values

 

 

java Main -pairs slave master

注意想接收多个value的参数需要设置成List<String>类型，boolean类型默认arity为0，String、Integer、int、Long、long默认arity都为1。

 

 

可变参数值数量，设置variableArity=true，你可以指定一个参数接收不定数量的values

 

@Parameter(names = "-foo", variableArity = true)
public List<String> foo = new ArrayList<String>();

下面两个例子一个接收2个参数，一个接收3个参数

 

 

program -foo a1 a2 a3 -bar
program -foo a1 -bar

11. 多重选项名

同一个选项（option）可以有不同别名，比如--recursive，可以有一个缩写-r，可以通过给names设置多个值实现

 

@Parameter(names = { "-d", "--outputDirectory" }, description = "Directory")
private String outputDirectory;

下面两种都可以给outputDirectory赋值

 

 

</pre><pre name="code" class="java">java Main -d /tmp
java Main --outputDirectory /tmp

12. 其他选项配置

 

JCommander#setCaseSensitiveOptions（boolean）：选项是否大小写敏感，如果设置成true，则‘-option' 和'-OPTION'是不同的选项

JCommander#setAllowAbbreviatedOptions（boolean）：打开选项缩写功能，’-op‘可以表示’-option‘选项，如果选项缩写太模糊不能定位到某个选项，则会throw一个ParameterException

 

 

13. 必须和可选选项

@Parameter annotation的required设置为true则表示此选项为必须的，否则为可选（默认为可选）

 

@Parameter(names = "-host", required = true)
private String host;

 

14. 默认值

一般情况下直接给选项赋值就可以了

 

private Integer logLevel = 3;

如果有更复杂的情况，比如对某些选项可以再不同的类里重复使用，或者你想把所有的default value都存在同一个地方比如一个XML文件，这些可以通过实现IDefaultProvider接口达成

 

 

public interface IDefaultProvider {
  /**
   * @param optionName The name of the option as specified in the names() attribute
   * of the @Parameter option (e.g. "-file").
   *
   * @return the default value for this option.
   */
  String getDefaultValueFor(String optionName);
}

实例

 

 

//这是个内部类

private static final IDefaultProvider DEFAULT_PROVIDER = new IDefaultProvider() {
  @Override
  public String getDefaultValueFor(String optionName) {
    return "-debug".equals(optionName) ? "false" : "42";
  }
};

// ...

JCommander jc = new JCommander(new Args());
jc.setDefaultProvider(DEFAULT_PROVIDER); //把default provider传入

15. 帮助选项

 

非常简单

 

@Parameter(names = "--help", help = true)
private boolean help;

 

 

16. 更多复杂的命令语法

想git之类的工具，除了git命令本身需要选项，它还包含一些子命令，如git commit，子命令本身也包含一些选项

 

git commit --amend -m "Bug fix"

上面的命令中，commit在JCommander中叫做’commands‘， 我们要为这个子命令单独创建一个类

 

 

@Parameters(separators = "=", commandDescription = "Record changes to the repository")
private class CommandCommit {

  @Parameter(description = "The list of files to commit")
  private List<String> files;

  @Parameter(names = "--amend", description = "Amend")
  private Boolean amend = false;

  @Parameter(names = "--author")
  private String author;
}

再为另一个git命令add创建一个类

 

 

@Parameters(commandDescription = "Add file contents to the index")
public class CommandAdd {

  @Parameter(description = "File patterns to add to the index")
  private List<String> patterns;

  @Parameter(names = "-i")
  private Boolean interactive = false;
}

创建好后要在JCommander对象里通过addCommand注册这些命令，当然我们也可以创建一个主要的参数类来接受git的参数

 

 

CommandMain cm = new CommandMain();
JCommander jc = new JCommander(cm);

CommandAdd add = new CommandAdd();
jc.addCommand("add", add);
CommandCommit commit = new CommandCommit();
jc.addCommand("commit", commit);

jc.parse("-v", "commit", "--amend", "--author=cbeust", "A.java", "B.java");

Assert.assertTrue(cm.verbose);
Assert.assertEquals(jc.getParsedCommand(), "commit");
Assert.assertTrue(commit.amend);
Assert.assertEquals(commit.author, "cbeust");
Assert.assertEquals(commit.files, Arrays.asList("A.java", "B.java"));

 

17. Exception

JCommander发现错误时会抛出ParameterExcpetion，这是一个runtime exception

 

 

18. usage

可以再JCommander实例中调用usage（）方法获取命令行使用方法

 

 

19. 隐藏参数

如果不想某些选项出现在usage里，可以隐藏他们

 

@Parameter(names = "-debug", description = "Debug mode", hidden = true)
private boolean debug = false;

 

20. 国际化

选项的描述（description）可以国际化，首先在类上使用@Parameter指定消息bundle的名字，然后在选项的@Parameter中使用descriptionKey指定bundle中的key

 

@Parameters(resourceBundle = "MessageBundle")
private class ArgsI18N2 {
  @Parameter(names = "-host", description = "Host", descriptionKey = "host")
  String hostName;
}

在MessageBundle中，定义host如下

 

 

host：主机

21. 参数代理

 

使用@ParameterDelegate可以在主参数类中引用其他的代理参数类

 

class Delegate {
  @Parameter(names = "-port")
  private int port;
}

class MainParams {
  @Parameter(names = "-v")
  private boolean verbose;

  @ParametersDelegate
  private Delegate delegate = new Delegate();
}

使用时只需在JCommander中指定主参数类

 

 

MainParams p = new MainParams();
new JCommander(p).parse("-v", "-port", "1234");
Assert.assertTrue(p.isVerbose);
Assert.assertEquals(p.delegate.port, 1234);

22. 动态参数

 

JCommander允许接收没有预先定义的选项，比如’-Da=b -Dc=d‘， Da和Dc没有在参数类中定义，这些参数要用@DynamicParameter annotation标记的类型为Map<String, String>的选项接收，动态参数可以重复多次

 

@DynamicParameter(names = "-D", description = "Dynamic parameters go here")
private Map<String, String> params = new HashMap<String, String>();

通过使用assignment属性，可以用其他符号代替’=‘作为赋值符号

 

 

 

 

 

 

 

http://blog.csdn.net/navyhu/article/details/40430267