WordCount 实例

35 篇文章 0 订阅

 http://www.iteye.com/topic/606962

http://www.iteye.com/topic/1117343

看了到Hadoop的代码,还是不知道他的执行流程,怎么办呢。我想到了日志,在hadoop的目录下,有log4j,那就用户Log4j来记录Hadoop的执行过程吧.
Java代码 复制代码  收藏代码
  1.   
  2.   
  3. import java.io.IOException;   
  4. import java.util.StringTokenizer;   
  5.   
  6. import org.apache.hadoop.conf.Configuration;   
  7. import org.apache.hadoop.fs.Path;   
  8. import org.apache.hadoop.io.IntWritable;   
  9. import org.apache.hadoop.io.Text;   
  10. import org.apache.hadoop.mapreduce.Job;   
  11. import org.apache.hadoop.mapreduce.Mapper;   
  12. import org.apache.hadoop.mapreduce.Reducer;   
  13. import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;   
  14. import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;   
  15. import org.apache.hadoop.util.GenericOptionsParser;   
  16. import org.apache.log4j.Logger;   
  17.   
  18. public class WordCount {   
  19.   
  20.   public static Logger loger = Wloger.loger;   
  21.   
  22.   /**  
  23.    * TokenizerMapper 继续自 Mapper<Object, Text, Text, IntWritable>  
  24.    *  
  25.    * [一个文件就一个map,两个文件就会有两个map]  
  26.    * map[这里读入输入文件内容 以" \t\n\r\f" 进行分割,然后设置 word ==> one 的key/value对]  
  27.    *  
  28.    * @param Object  Input key Type:  
  29.    * @param Text    Input value Type:  
  30.    * @param Text    Output key Type:  
  31.    * @param IntWritable Output value Type:  
  32.    *  
  33.    * Writable的主要特点是它使得Hadoop框架知道对一个Writable类型的对象怎样进行serialize以及deserialize.  
  34.    * WritableComparable在Writable的基础上增加了compareT接口,使得Hadoop框架知道怎样对WritableComparable类型的对象进行排序。  
  35.    *  
  36.    * @author yangchunlong.tw  
  37.    *  
  38.    */  
  39.   public static class TokenizerMapper   
  40.        extends Mapper<Object, Text, Text, IntWritable>{   
  41.   
  42.     private final static IntWritable one = new IntWritable(1);   
  43.     private Text word = new Text();   
  44.     public void map(Object key, Text value, Context context   
  45.                     ) throws IOException, InterruptedException {   
  46.       loger.info("Map <key>"+key+"</key>");   
  47.       loger.info("Map <value>"+value+"</key>");   
  48.       StringTokenizer itr = new StringTokenizer(value.toString());   
  49.       while (itr.hasMoreTokens()) {   
  50.         String wordstr = itr.nextToken();   
  51.         word.set(wordstr);   
  52.         loger.info("Map <word>"+wordstr+"</word>");   
  53.         context.write(word, one);   
  54.       }   
  55.     }   
  56.   }   
  57.   
  58.   /**  
  59.    * IntSumReducer 继承自 Reducer<Text,IntWritable,Text,IntWritable>  
  60.    *  
  61.    * [不管几个Map,都只有一个Reduce,这是一个汇总]  
  62.    * reduce[循环所有的map值,把word ==> one 的key/value对进行汇总]  
  63.    *  
  64.    * 这里的key为Mapper设置的word[每一个key/value都会有一次reduce]  
  65.    *  
  66.    * 当循环结束后,最后的确context就是最后的结果.  
  67.    *  
  68.    * @author yangchunlong.tw  
  69.    *  
  70.    */  
  71.   public static class IntSumReducer   
  72.        extends Reducer<Text,IntWritable,Text,IntWritable> {   
  73.     private IntWritable result = new IntWritable();   
  74.   
  75.     public void reduce(Text key, Iterable<IntWritable> values,   
  76.                        Context context   
  77.                        ) throws IOException, InterruptedException {   
  78.       loger.info("Reduce <key>"+key+"</key>");   
  79.       loger.info("Reduce <value>"+values+"</key>");   
  80.       int sum = 0;   
  81.       for (IntWritable val : values) {   
  82.         sum += val.get();   
  83.       }   
  84.       result.set(sum);   
  85.       loger.info("Reduce <sum>"+sum+"</sum>");   
  86.       context.write(key, result);   
  87.     }   
  88.   }   
  89.   
  90.   public static void main(String[] args) throws Exception {   
  91.     Configuration conf = new Configuration();   
  92.     String[] otherArgs = new GenericOptionsParser(conf, args).getRemainingArgs();   
  93.     /**  
  94.      * 这里必须有输入/输出  
  95.      */  
  96.     if (otherArgs.length != 2) {   
  97.       System.err.println("Usage: wordcount <in> <out>");   
  98.       System.exit(2);   
  99.     }   
  100.     Job job = new Job(conf, "word count");   
  101.     job.setJarByClass(WordCount.class);//主类   
  102.     job.setMapperClass(TokenizerMapper.class);//mapper   
  103.     job.setCombinerClass(IntSumReducer.class);//作业合成类   
  104.     job.setReducerClass(IntSumReducer.class);//reducer   
  105.     job.setOutputKeyClass(Text.class);//设置作业输出数据的关键类   
  106.     job.setOutputValueClass(IntWritable.class);//设置作业输出值类   
  107.     FileInputFormat.addInputPath(job, new Path(otherArgs[0]));//文件输入   
  108.     FileOutputFormat.setOutputPath(job, new Path(otherArgs[1]));//文件输出   
  109.     System.exit(job.waitForCompletion(true) ? 0 : 1);//等待完成退出.   
  110.   }   
  111. }  
import java.io.IOException;
import java.util.StringTokenizer;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.util.GenericOptionsParser;
import org.apache.log4j.Logger;

public class WordCount {

  public static Logger loger = Wloger.loger;

  /**
   * TokenizerMapper 继续自 Mapper<Object, Text, Text, IntWritable>
   *
   * [一个文件就一个map,两个文件就会有两个map]
   * map[这里读入输入文件内容 以" \t\n\r\f" 进行分割,然后设置 word ==> one 的key/value对]
   *
   * @param Object  Input key Type:
   * @param Text    Input value Type:
   * @param Text    Output key Type:
   * @param IntWritable Output value Type:
   *
   * Writable的主要特点是它使得Hadoop框架知道对一个Writable类型的对象怎样进行serialize以及deserialize.
   * WritableComparable在Writable的基础上增加了compareT接口,使得Hadoop框架知道怎样对WritableComparable类型的对象进行排序。
   *
   * @author yangchunlong.tw
   *
   */
  public static class TokenizerMapper
       extends Mapper<Object, Text, Text, IntWritable>{

    private final static IntWritable one = new IntWritable(1);
    private Text word = new Text();
    public void map(Object key, Text value, Context context
                    ) throws IOException, InterruptedException {
      loger.info("Map <key>"+key+"</key>");
      loger.info("Map <value>"+value+"</key>");
      StringTokenizer itr = new StringTokenizer(value.toString());
      while (itr.hasMoreTokens()) {
    	String wordstr = itr.nextToken();
        word.set(wordstr);
        loger.info("Map <word>"+wordstr+"</word>");
        context.write(word, one);
      }
    }
  }

  /**
   * IntSumReducer 继承自 Reducer<Text,IntWritable,Text,IntWritable>
   *
   * [不管几个Map,都只有一个Reduce,这是一个汇总]
   * reduce[循环所有的map值,把word ==> one 的key/value对进行汇总]
   *
   * 这里的key为Mapper设置的word[每一个key/value都会有一次reduce]
   *
   * 当循环结束后,最后的确context就是最后的结果.
   *
   * @author yangchunlong.tw
   *
   */
  public static class IntSumReducer
       extends Reducer<Text,IntWritable,Text,IntWritable> {
    private IntWritable result = new IntWritable();

    public void reduce(Text key, Iterable<IntWritable> values,
                       Context context
                       ) throws IOException, InterruptedException {
      loger.info("Reduce <key>"+key+"</key>");
      loger.info("Reduce <value>"+values+"</key>");
      int sum = 0;
      for (IntWritable val : values) {
        sum += val.get();
      }
      result.set(sum);
      loger.info("Reduce <sum>"+sum+"</sum>");
      context.write(key, result);
    }
  }

  public static void main(String[] args) throws Exception {
    Configuration conf = new Configuration();
    String[] otherArgs = new GenericOptionsParser(conf, args).getRemainingArgs();
    /**
     * 这里必须有输入/输出
     */
    if (otherArgs.length != 2) {
      System.err.println("Usage: wordcount <in> <out>");
      System.exit(2);
    }
    Job job = new Job(conf, "word count");
    job.setJarByClass(WordCount.class);//主类
    job.setMapperClass(TokenizerMapper.class);//mapper
    job.setCombinerClass(IntSumReducer.class);//作业合成类
    job.setReducerClass(IntSumReducer.class);//reducer
    job.setOutputKeyClass(Text.class);//设置作业输出数据的关键类
    job.setOutputValueClass(IntWritable.class);//设置作业输出值类
    FileInputFormat.addInputPath(job, new Path(otherArgs[0]));//文件输入
    FileOutputFormat.setOutputPath(job, new Path(otherArgs[1]));//文件输出
    System.exit(job.waitForCompletion(true) ? 0 : 1);//等待完成退出.
  }
}


这里输出了每一次Map,每一次Reduce.结果如下:
Java代码 复制代码  收藏代码
  1. f1 ==>Map Result   
  2. Map <key>0</key>   
  3. Map <value>ycl ycl is ycl good</key>   
  4. Map <word>ycl</word>   
  5. Map <word>ycl</word>   
  6. Map <word>is</word>   
  7. Map <word>ycl</word>   
  8. Map <word>good</word>   
  9.   
  10. f1 ==>Reduce Result   
  11. Reduce <key>good</key>   
  12. Reduce <value>org.apache.hadoop.mapreduce.ReduceContext$ValueIterable@1dfc547</key>   
  13. Reduce <sum>1</sum>   
  14. Reduce <key>is</key>   
  15. Reduce <value>org.apache.hadoop.mapreduce.ReduceContext$ValueIterable@1dfc547</key>   
  16. Reduce <sum>1</sum>   
  17. Reduce <key>ycl</key>   
  18. Reduce <value>org.apache.hadoop.mapreduce.ReduceContext$ValueIterable@1dfc547</key>   
  19. Reduce <sum>3</sum>   
  20.   
  21. f2 ==>Map Result   
  22. Map <key>0</key>   
  23. Map <value>hello ycl hello lg</key>   
  24. Map <word>hello</word>   
  25. Map <word>ycl</word>   
  26. Map <word>hello</word>   
  27. Map <word>lg</word>   
  28.   
  29. f2 ==>Reduce Result   
  30. Reduce <key>hello</key>   
  31. Reduce <value>org.apache.hadoop.mapreduce.ReduceContext$ValueIterable@10f6d3</key>   
  32. Reduce <sum>2</sum>   
  33. Reduce <key>lg</key>   
  34. Reduce <value>org.apache.hadoop.mapreduce.ReduceContext$ValueIterable@10f6d3</key>   
  35. Reduce <sum>1</sum>   
  36. Reduce <key>ycl</key>   
  37. Reduce <value>org.apache.hadoop.mapreduce.ReduceContext$ValueIterable@10f6d3</key>   
  38. Reduce <sum>1</sum>   
  39.   
  40. f1,f2 ==> Reduce Result   
  41. Reduce <key>good</key>   
  42. Reduce <value>org.apache.hadoop.mapreduce.ReduceContext$ValueIterable@1989f84</key>   
  43. Reduce <sum>1</sum>   
  44. Reduce <key>hello</key>   
  45. Reduce <value>org.apache.hadoop.mapreduce.ReduceContext$ValueIterable@1989f84</key>   
  46. Reduce <sum>2</sum>   
  47. Reduce <key>is</key>   
  48. Reduce <value>org.apache.hadoop.mapreduce.ReduceContext$ValueIterable@1989f84</key>   
  49. Reduce <sum>1</sum>   
  50. Reduce <key>lg</key>   
  51. Reduce <value>org.apache.hadoop.mapreduce.ReduceContext$ValueIterable@1989f84</key>   
  52. Reduce <sum>1</sum>   
  53. Reduce <key>ycl</key>   
  54. Reduce <value>org.apache.hadoop.mapreduce.ReduceContext$ValueIterable@1989f84</key>   
  55. Reduce <sum>4</sum>  
f1 ==>Map Result
Map <key>0</key>
Map <value>ycl ycl is ycl good</key>
Map <word>ycl</word>
Map <word>ycl</word>
Map <word>is</word>
Map <word>ycl</word>
Map <word>good</word>

f1 ==>Reduce Result
Reduce <key>good</key>
Reduce <value>org.apache.hadoop.mapreduce.ReduceContext$ValueIterable@1dfc547</key>
Reduce <sum>1</sum>
Reduce <key>is</key>
Reduce <value>org.apache.hadoop.mapreduce.ReduceContext$ValueIterable@1dfc547</key>
Reduce <sum>1</sum>
Reduce <key>ycl</key>
Reduce <value>org.apache.hadoop.mapreduce.ReduceContext$ValueIterable@1dfc547</key>
Reduce <sum>3</sum>

f2 ==>Map Result
Map <key>0</key>
Map <value>hello ycl hello lg</key>
Map <word>hello</word>
Map <word>ycl</word>
Map <word>hello</word>
Map <word>lg</word>

f2 ==>Reduce Result
Reduce <key>hello</key>
Reduce <value>org.apache.hadoop.mapreduce.ReduceContext$ValueIterable@10f6d3</key>
Reduce <sum>2</sum>
Reduce <key>lg</key>
Reduce <value>org.apache.hadoop.mapreduce.ReduceContext$ValueIterable@10f6d3</key>
Reduce <sum>1</sum>
Reduce <key>ycl</key>
Reduce <value>org.apache.hadoop.mapreduce.ReduceContext$ValueIterable@10f6d3</key>
Reduce <sum>1</sum>

f1,f2 ==> Reduce Result
Reduce <key>good</key>
Reduce <value>org.apache.hadoop.mapreduce.ReduceContext$ValueIterable@1989f84</key>
Reduce <sum>1</sum>
Reduce <key>hello</key>
Reduce <value>org.apache.hadoop.mapreduce.ReduceContext$ValueIterable@1989f84</key>
Reduce <sum>2</sum>
Reduce <key>is</key>
Reduce <value>org.apache.hadoop.mapreduce.ReduceContext$ValueIterable@1989f84</key>
Reduce <sum>1</sum>
Reduce <key>lg</key>
Reduce <value>org.apache.hadoop.mapreduce.ReduceContext$ValueIterable@1989f84</key>
Reduce <sum>1</sum>
Reduce <key>ycl</key>
Reduce <value>org.apache.hadoop.mapreduce.ReduceContext$ValueIterable@1989f84</key>
Reduce <sum>4</sum>

正常人应该能分析出map/reduce的执行机制,比如有两个输入文件,map/reduce是一个文件一个文件进行处理的,每map一个输入文件就会reduce一次,最后再进行总的reduce.
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值