【转】分析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实现中。