【转】分析Hadoop自带WordCount例子的执行过程(3)

继续向下看：

Option fs = OptionBuilder.withArgName("local|namenode:port")

.hasArg()

.withDescription("specify a namenode")

.create("fs");

opts.addOption(fs);

有一个很重要的类OptionBuilder，它才完成了“充实”一个Option的过程，然后经过多次调用，会将多个Option都添加到opts列表中。

看一看OptionBuilder类的withArgName()方法：
/**

* The next Option created will have the specified argument value

* name.

*

* @param name the name for the argument value

* @return the OptionBuilder instance

*/

public static OptionBuilder withArgName(String name)

{

OptionBuilder.argName = name;

return instance;

}

上面，为一个OptionBuilder的实例指定一个参数(argName)为name，实际上是返回了一个具有name的OptionBuilder实例。
然后，又调用了hasArg()方法，它也是OptionBuilder类的静态方法：
/**

* The next Option created will require an argument value.

*

* @return the OptionBuilder instance

*/

public static OptionBuilder hasArg()

{

OptionBuilder.numberOfArgs = 1;

return instance;

}

为刚才指定参数名的那个OptionBuilder实例设置了参数的个数，因为第一次设置，当然个数为1了。
调用withDescription()方法来设定描述信息：
/**

* The next Option created will have the specified description

*

* @param newDescription a description of the Option's purpose

* @return the OptionBuilder instance

*/

public static OptionBuilder withDescription(String newDescription)

{

OptionBuilder.description = newDescription;

return instance;

}

比较关键的是最后一步调用，通过调用OptionBuilder类的create()方法才真正完成了一个Option的创建：
/**

* Create an Option using the current settings and with

* the specified Option <code>char</code>.

*

* @param opt the <code>java.lang.String</code> representation

* of the Option

* @return the Option instance

* @throws IllegalArgumentException if <code>opt</code> is not

* a valid character. See Option.

*/

public static Option create(String opt)

throws IllegalArgumentException

{

// create the option

Option option = new Option(opt, description);

// set the option properties

option.setLongOpt(longopt);

option.setRequired(required);

option.setOptionalArg(optionalArg);

option.setArgs(numberOfArgs);

option.setType(type);

option.setValueSeparator(valuesep);

option.setArgName(argName);

option.setArgPattern(argPattern, limit);

// reset the OptionBuilder properties

OptionBuilder.reset();

// return the Option instance

return option;

}

从上面一个Option的设置，我们可以看出来，OptionBuilder类其实是一个辅助工具，用来收集与一个Option相关的信息，从而将这些信息一次全部赋予到一个新建的Option对象上，这个对象现在具有详细的信息了。

接着，通过CommandLineParser parser的parse方法，可以知道public abstract class Parser implements CommandLineParser，从抽象类Parser中找到parse的实现：
public CommandLine parse(Options options, String[] arguments,

boolean stopAtNonOption)

throws ParseException

{

return parse(options, arguments, null, stopAtNonOption);

}

参数stopAtNonOption表明，如果解析过程中遇到的是一个空选项是否仍然继续解析。从前面parseGeneralOptions方法 中commandLine = parser.parse(opts, args, true);可知：我们传递过来一个true。
再次调用Parser类的重载成员方法parse()，如下所示，解析过程非常详细：
/**

* Parse the arguments according to the specified options and

* properties.

*

* @param options the specified Options

* @param arguments the command line arguments

* @param properties command line option name-value pairs

* @param stopAtNonOption stop parsing the arguments when the first

* non option is encountered.

*

* @return the list of atomic option and value tokens

*

* @throws ParseException if there are any problems encountered

* while parsing the command line tokens.

*/

public CommandLine parse(Options options, String[] arguments,

Properties properties, boolean stopAtNonOption)

throws ParseException

{

// initialise members

this.options = options;

requiredOptions = options.getRequiredOptions();

cmd = new CommandLine();

boolean eatTheRest = false;

if (arguments == null)

{

arguments = new String[0];

}

List tokenList = Arrays.asList(flatten(this.options,

arguments,

stopAtNonOption));

ListIterator iterator = tokenList.listIterator();

// process each flattened token

while (iterator.hasNext())

{

String t = (String) iterator.next();

// the value is the double-dash

if ("--".equals(t))

{

eatTheRest = true;

}

// the value is a single dash

else if ("-".equals(t))

{

if (stopAtNonOption)

{

eatTheRest = true;

}

else

{

cmd.addArg(t);

}

}

// the value is an option

else if (t.startsWith("-"))

{

if (stopAtNonOption && !options.hasOption(t))

{

eatTheRest = true;

cmd.addArg(t);

}

else

{

processOption(t, iterator);

}

}

// the value is an argument

else

{

cmd.addArg(t);

if (stopAtNonOption)

{

eatTheRest = true;

}

}

// eat the remaining tokens

if (eatTheRest)

{

while (iterator.hasNext())

{

String str = (String) iterator.next();

// ensure only one double-dash is added

if (!"--".equals(str))

{

cmd.addArg(str);

}

}

}

}

processProperties(properties);

checkRequiredOptions();

return cmd;

}

解析之后，返回CommandLine类的实例，从而GenericOptionsParser类的成员变量commandLine获取到了一个引用。commandLine是GenericOptionsParser类的一个私有成员变量。

看一下CommandLine类的实现：
package org.apache.commons.cli;

import java.util.Collection;

import java.util.HashMap;

import java.util.Iterator;

import java.util.LinkedList;

import java.util.List;

import java.util.Map;

/**

* Represents list of arguments parsed against

* a {@link Options} descriptor.

*

* It allows querying of a boolean {@link #hasOption(String opt)},

* in addition to retrieving the {@link #getOptionValue(String opt)}

* for options requiring arguments.

*/

public class CommandLine {

// 不能识别的 options/arguments

private List args = new LinkedList();

/** the processed options */

private Map options = new HashMap();

/** the option name map */

private Map names = new HashMap();

/** Map of unique options for ease to get complete list of options */

private Map hashcodeMap = new HashMap();

/** the processed options */

private Option[] optionsArray;

// 创建一个命令行CommandLine的实例。

CommandLine()

{

// nothing to do

}

// 从options这个HashMap中查看，判断是否opt已经被设置了

public boolean hasOption(String opt)

{

return options.containsKey(opt);

}

// 调用hasOption()方法，从options这个HashMap中查看，判断是否opt已经被设置了

public boolean hasOption(char opt)

{

return hasOption(String.valueOf(opt));

}

// 根据String opt返回Option的Object类型

public Object getOptionObject(String opt)

{

String res = getOptionValue(opt);

if (!options.containsKey(opt))

{

return null;

}

Object type = ((Option) options.get(opt)).getType();

return (res == null) ? null : TypeHandler.createValue(res, type);

}

// 根据char opt返回Option的Object类型

public Object getOptionObject(char opt)

{

return getOptionObject(String.valueOf(opt));

}

// 根据指定的String opt获取Option的值

public String getOptionValue(String opt)

{

String[] values = getOptionValues(opt);

return (values == null) ? null : values[0];

}

// 根据指定的char opt获取Option的值

public String getOptionValue(char opt)

{

return getOptionValue(String.valueOf(opt));

}

/**

* Retrieves the array of values, if any, of an option.

*

* @param opt string name of the option

* @return Values of the argument if option is set, and has an argument,

* otherwise null.

*/

public String[] getOptionValues(String opt)

{

opt = Util.stripLeadingHyphens(opt);

String key = opt;

if (names.containsKey(opt))

{

key = (String) names.get(opt);

}

if (options.containsKey(key))

{

return ((Option) options.get(key)).getValues();

}

return null;

}

// 根据指定的String opt，返回Option的值的一个数组

public String[] getOptionValues(char opt)

{

return getOptionValues(String.valueOf(opt));

}

// 根据指定的String opt和String defaultValue获取Option的值

public String getOptionValue(String opt, String defaultValue)

{

String answer = getOptionValue(opt);

return (answer != null) ? answer : defaultValue;

}

// 根据指定的char opt和String defaultValue获取Option的值

public String getOptionValue(char opt, String defaultValue)

{

return getOptionValue(String.valueOf(opt), defaultValue);

}

// 返回不能够解析的Option和参数的一个数组

public String[] getArgs()

{

String[] answer = new String[args.size()];

args.toArray(answer);

return answer;

}

// 返回不能够解析的Option和参数的一个列表

public List getArgList()

{

return args;

}

/**

* jkeyes

* - commented out until it is implemented properly

* <p>Dump state, suitable for debugging.</p>

*

* @return Stringified form of this object

*/

public String toString() {

StringBuffer buf = new StringBuffer();



buf.append("[ CommandLine: [ options: ");

buf.append(options.toString());

buf.append(" ] [ args: ");

buf.append(args.toString());

buf.append(" ] ]");



return buf.toString();

}

/**

* Add left-over unrecognized option/argument.

*

* @param arg the unrecognised option/argument.

*/

void addArg(String arg)

{

args.add(arg);

}

// 向CommandLine中添加一个Option，其中Option的值(可能多个)被存储

void addOption(Option opt)

{

hashcodeMap.put(new Integer(opt.hashCode()), opt);

String key = opt.getKey();

if (key == null)

{

key = opt.getLongOpt();

}

else

{

names.put(opt.getLongOpt(), key);

}

options.put(key, opt);

}

// 返回CommandLine的Option 成员表的一个迭代器

public Iterator iterator()

{

return hashcodeMap.values().iterator();

}

// 返回处理过的Option的对象数组

public Option[] getOptions()

{

Collection processed = options.values();

// reinitialise array

optionsArray = new Option[processed.size()];

// return the array

return (Option[]) processed.toArray(optionsArray);

}

}

一个CommandLine中包含一个重要的HashMap，里面存储的是键值对，即(key, opt)，通过它可以非常方便地设置和访问。

接着在parseGeneralOptions方法中调用processGeneralOptions()方法，进行处理：
processGeneralOptions(conf, commandLine);


processGeneralOptions的处理过程如下：

/**

* Modify configuration according user-specified generic options

* @param conf Configuration to be modified

* @param line User-specified generic options

*/

private void processGeneralOptions(Configuration conf,

CommandLine line) {

if (line.hasOption("fs")) {

conf.set("fs.default.name", line.getOptionValue("fs"));

}

if (line.hasOption("jt")) {

conf.set("mapred.job.tracker", line.getOptionValue("jt"));

}

if (line.hasOption("conf")) {

conf.addResource(new Path(line.getOptionValue("conf")));

}

if (line.hasOption('D')) {

String[] property = line.getOptionValues('D');

for(int i=0; i<property.length-1; i=i+2) {

if (property[i]!=null)

conf.set(property[i], property[i+1]);

}

}

}

传进去一个CommandLine实例，通过CommanLine的信息，来设置Configuration conf对象。设置Configuration conf对象的目的是：为Hadoop的Tool工作而设置的，比如WordCount这个工具，在运行开始时需要获取到Hadoop的配置信息的，这个 就需要从这里设置的Configuration conf对象来获取。

上面这个processGeneralOptions()方法，是根据CommanLine的对象，获取到所有参数值的一个数组，并返回。
到此位置，前面都是为了初始化一个GenericOptionsParser parser解析器所做的工作：
GenericOptionsParser parser = new GenericOptionsParser(conf, args);

进而，可以使用 GenericOptionsParser类的实例parser 来获取Hadoop的通用参数了：

//get the args w/o generic hadoop args

String[] toolArgs = parser.getRemainingArgs();

已经具备了运行Hadoop工具的条件了，可以启动了：

return tool.run(toolArgs);
可以根据返回的状态码检查工具运行情况。

上面Tool tool就是我们实例化的WordCount对象，这时候才进入到WordCount实现中。