MahoutDriver运作机制-mahout源码学习及总结

欢迎喜欢深入了解推荐系统和mahout的兄弟加入群     推荐系统之Mahout  135918911

 

mahout入口类MahoutDriver

 

如果我们想要研究MahoutDriver的源码，没有什么比测试类更好的了，下面我们看一下测试类

 

public final class MahoutDriverTest {

     //测试MahoutDriver.main方法

    @Test
     public void testMain() throws Throwable {

    //我们注释掉原有的简单help参数，增加自定定义参数
    //MahoutDriver.main(new String[] {"itemsimilarity", "help"});
    MahoutDriver.main(new String[] {"itemsimilarity", "-Djava.home=wwww.c.cn"," -input"," c:/c/c","-output", "d"," e", "f"});
    }

}

 

 下面我们来看一下MahoutDriver方法组成，下面先粘贴上其方法大纲

 

 

先简单介绍一下main方法之外的一些方法的作用

 

 //判断我们要使用的mahout类是否已经过期，过期返回true，不过期返回false

 private static boolean isDeprecated(Properties mainClasses, String keyString) {
    return "deprecated".equalsIgnoreCase(shortName(mainClasses.getProperty(keyString)));
  }

 

 

//加载资源属性文件

private static Properties loadProperties(String resource) throws IOException

//模拟linux中的shift命令，及让第一个参数失效(数组中index=0)，及重新构造数组，保留index1位置开始到结束的全部参数

private static String[] shift(String[] args)

//取出字符串中的短名缩写

//例如org.apache.mahout.cf.taste.hadoop.similarity.item.ItemSimilarityJob = itemsimilarity : Compute the item-item-similarities for item-based collaborative filtering

private static String shortName(String valueString) {
    return valueString.contains(":") ? valueString.substring(0, valueString.indexOf(':')).trim() : valueString;
}

  private static String desc(String valueString) {
    return valueString.contains(":") ? valueString.substring(valueString.indexOf(':')).trim() : valueString;
  }

 

介绍一下MahoutDriver的核心代码，这里我们就不粘贴全部代码了，我们分逻辑块说明

 1.创建programdriver, 使用hadoop的驱动工具类进行相关类的实例化，及调用

 ProgramDriver programDriver = new ProgramDriver();
 2. 首先加载mahout配置文件driver.classes.props ,如果该文件不存在的话，我们加载driver.classes.default.props ，如果都不存在就会退出，停止运行，如果我们需要新添加算法类，可以再两个文件中添加

    Properties mainClasses = loadProperties("driver.classes.props");
    if (mainClasses == null) {
      mainClasses = loadProperties("driver.classes.default.props");
    }
    if (mainClasses == null) {
      throw new IOException("Can't load any properties file?");
    }

3.验证是否是算法类简称调用，算法类是否过时，并创建描述信息

 

    boolean foundShortName = false;
    for (Object key :  mainClasses.keySet()) {
      String keyString = (String) key;

 首先判断是我们是否是通过算法类简称及shortName调用，  

      if (args.length > 0 && shortName(mainClasses.getProperty(keyString)).equals(args[0])) {
        foundShortName = true;
      }

    第二步 判断是否是通过算法类全路径调用,如果是全路径调用但是获取算法类简称 是过时废弃的 即等于deprecated 那么退出main方法，防止我们通过全路径方式使用过时的算法类    

      if (args.length > 0 && keyString.equalsIgnoreCase(args[0]) && isDeprecated(mainClasses, keyString)) {
        log.error(desc(mainClasses.getProperty(keyString)));
        return;
      }

       不处理已经过时废弃的类
      if (isDeprecated(mainClasses, keyString)) {
        continue;
      }

    第三步 建立 全部算法类的描述信息类就是描述该类是做什么的，参数等等，

      addClass(programDriver, keyString, mainClasses.getProperty(keyString));
    }

 

 

 

4.验证我们是否调用帮助信息，如果是的话直接输出帮助信息，

   如果我们是使用全路径调用的，并没有使用简称，创建描述类，个人认为这里主要是针对第一个参数没有在配置文件中注册的情况出现的处理办法，最后让arg[0]失效，其他数组索引全部减一，（内部是通过copy数组实现的）

   if (args.length < 1 || args[0] == null || "-h".equals(args[0]) || "--help".equals(args[0])) {
      programDriver.driver(args);
    }

    String progName = args[0];
    if (!foundShortName) {
      addClass(programDriver, progName, progName);
    }
    shift(args);

 

5. 加载progName + ".props"指定配置文件（progName 就是我们传递的第一个参数），如果不存在的话，那么我们就只能使用命令行参数了

最后对参数进行封装处理

 Properties mainProps = loadProperties(progName + ".props");
    if (mainProps == null) {
      log.warn("No {}.props found on classpath, will use command-line arguments only", progName);
      mainProps = new Properties();
    }

   接下来对命令参数进行处理 分三步， 解析命令行参数 ，添加我们命令行没有覆盖的参数,还原命令行参数  

     Map<String,String[]> argMap = Maps.newHashMap();

    int i = 0;
    while (i < args.length && args[i] != null) {
      List<String> argValues = Lists.newArrayList();

      //取到当前参数，该值是用来作为map中的key使用的，

      1)arg一般情况下为当前参数 args[i]  当前args[i]后面的一系列参数都会作为args[i]的参数，除非我们查找到带 “ -  ”横杠的参数 

      2)但是如果是java命令行参数的话，该值会被替换为args[i]中=符号前面的部分，args[i]中=符号后面的字符串作为值
      String arg = args[i];
      i++;

       //验证是否是java的命令行参数设置
      if (arg.startsWith("-D")) { // '-Dkey=value' or '-Dkey=value1,value2,etc' case
        String[] argSplit = arg.split("=");
        arg = argSplit[0];
        if (argSplit.length == 2) { 传参格式必须正确长度必须是2
          argValues.add(argSplit[1]);
        }
      } else { 非java命令行参数value值添加处理                                     // '-key [values]' or '--key [values]' case.
        while (i < args.length && args[i] != null) {

           //非java命令行参数处理，只要遇到-
          if (args[i].startsWith("-")) {
            break;
          }
          argValues.add(args[i]);
          i++;
        }
      }
      argMap.put(arg, argValues.toArray(new String[argValues.size()]));
    }

   添加没有被我们覆盖的其他默认参数

// Add properties from the .props file that are not overridden on the command line
    for (String key : mainProps.stringPropertyNames()) {

       //举例配置文件中内容为

       // #i|input = /path/to/input

       // #o|output = /path/to/output  

      String[] argNamePair = key.split("\\|");

      //简写参数及长写参数
      String shortArg = '-' + argNamePair[0].trim();
      String longArg = argNamePair.length < 2 ? null : "--" + argNamePair[1].trim();

     //如果传递命令参数中不包含该参数，添加进处理的参数集合中
      if (!argMap.containsKey(shortArg) && (longArg == null || !argMap.containsKey(longArg))) {
        argMap.put(longArg, new String[] {mainProps.getProperty(key)});
      }
    }

  将处理好后的参数进行封装中可以使用的参数

 // Now add command-line args
    List<String> argsList = Lists.newArrayList();
    argsList.add(progName);
    for (Map.Entry<String,String[]> entry : argMap.entrySet()) {
      String arg = entry.getKey();
      if (arg.startsWith("-D")) { // arg is -Dkey - if value for this !isEmpty(), then arg -> -Dkey + "=" + value
        String[] argValues = entry.getValue();
        if (argValues.length > 0 && !argValues[0].trim().isEmpty()) {
          arg += '=' + argValues[0].trim();
        }
        argsList.add(1, arg);
      } else {
        argsList.add(arg);
        for (String argValue : Arrays.asList(argMap.get(arg))) {
          if (!argValue.isEmpty()) {
            argsList.add(argValue);
          }
        }
      }
    }

6 使用hadoop工具类驱动我们的算法类运行，并接传递相关参数

programDriver.driver(argsList.toArray(new String[argsList.size()]));

 

下面简单介绍一下hadoop的工具类，程序驱动类

 

ProgramDriver 主要功能求实输出我们添加的全部类描述信息，主要属性是一个存放ProgramDescription的treemap集合，

其他方法为 

 

          printUsage,打印Treemap<ProgramDescription>中的全部描述信息 

          addClass 创建ProgramDescription 并接添加进treemap当中

          driver(String[] args) 通过args[0] 取到 ProgramDescription  反射调用指定类的main方法并接传递参数

          其核心代码以去除非空判断及打印全部信息等等

    ProgramDescription pgm = programs.get(args[0]);

    if (pgm == null) {

      System.out.println("Unknown program '" + args[0] + "' chosen.");

      printUsage(programs);

      System.exit(-1);

    }

    

    // Remove the leading argument and call main

    String[] new_args = new String[args.length - 1];

    for(int i=1; i < args.length; ++i) {

      new_args[i-1] = args[i];

    }

    //这里开始调用ProgramDescription 的invoke方法

    pgm.invoke(new_args);

 

下面介绍一下其很重要的静态内部类ProgramDescription

 

  

 

     这里paramTypes主要是申明我们在反射调用时传递的是string数组类型(因为反射调用的默认都是main方法) 

     static final Class<?>[] paramTypes = new Class<?>[] {String[].class};

     我们将来要反射调用的方法实例

     Mehod main      

      我们自己定义的程序描述信息

     String description

    探秘一下构造器 

    public ProgramDescription(Class<?> mainClass, 
                              String description)
      throws SecurityException, NoSuchMethodException {
      负责获取我们将来要反射调用的main函数的Method的实例

      this.main = mainClass.getMethod("main", paramTypes);
      this.description = description;// 算法的描述信息

    }

      

    探秘一下invoke 很简单的反射调用

    public void invoke(String[] args)

      throws Throwable {
      try {
        main.invoke(null, new Object[]{args});
      } catch (InvocationTargetException except) {
        throw except.getCause();
      }
    }