Hadoop的实例测试

Hadoop--海量文件的分布式计算处理方案
   Hadoop 是Google MapReduce的 一个Java实现。MapReduce是一种简化的分布式编程模式，让程序自动分布到一个由普通机器组成的超大集群上并发执行。就如同java程序员可以 不考虑内存泄露一样， MapReduce的run-time系统会解决输入数据的分布细节，跨越机器集群的程序执行调度，处理机器的失效，并且管理机器之间的通讯请求。这样的 模式允许程序员可以不需要有什么并发处理或者分布式系统的经验，就可以处理超大的分布式系统得资源。
       一、概论

    作为Hadoop程序员，他要做的事情就是：
    1、定义Mapper，处理输入的Key-Value对，输出中间结果。
    2、定义Reducer，可选，对中间结果进行规约，输出最终结果。
    3、定义InputFormat 和OutputFormat，可选，InputFormat将每行输入文件的内容转换为Java类供Mapper函数使用，不定义时默认为String。
    4、定义main函数，在里面定义一个Job并运行它。
  

    然后的事情就交给系统了。
    1.基本概念：Hadoop的HDFS实现了google的GFS文件系统，NameNode作为文件系统的负责调度运行在master， DataNode运行在每个机器上。同时Hadoop实现了Google的MapReduce，JobTracker作为MapReduce的总调度运行 在master，TaskTracker则运行在每个机器上执行Task。

    2.main()函数，创建JobConf，定义Mapper，Reducer，Input/OutputFormat 和输入输出文件目录，最后把Job提交給JobTracker，等待Job结束。

    3.JobTracker，创建一个InputFormat的实例，调用它的getSplits()方法，把输入目录的文件拆分成FileSplist作为Mapper task 的输入，生成Mapper task加入Queue。

    4.TaskTracker 向 JobTracker索求下一个Map/Reduce。
     
      Mapper Task先从InputFormat创建RecordReader，循环读入FileSplits的内容生成Key与Value，传给Mapper函数，处理完后中间结果写成SequenceFile.
      Reducer Task 从运行Mapper的TaskTracker的Jetty上使用http协议获取所需的中间内容（33%），Sort/Merge后（66%），执行Reducer函数，最后按照OutputFormat写入结果目录。

      TaskTracker 每10秒向JobTracker报告一次运行情况，每完成一个Task10秒后，就会向JobTracker索求下一个Task。

      Nutch项目的全部数据处理都构建在Hadoop之上，详见Scalable Computing with Hadoop。

       二、程序员编写的代码

    我们做一个简单的分布式的Grep，简单对输入文件进行逐行的正则匹配，如果符合就将该行打印到输出文件。因为是简单的全部输出，所以我们只要写Mapper函数，不用写Reducer函数，也不用定义Input/Output Format。

package demo.hadoop

public class HadoopGrep {

public static class RegMapper extends MapReduceBase implements Mapper {

   private Pattern pattern;

   public void configure(JobConf job) {
    pattern = Pattern.compile(job.get( " mapred.mapper.regex " ));
   }

   public void map(WritableComparable key, Writable value, OutputCollector output, Reporter reporter)
     throws IOException {
    String text = ((Text) value).toString();
    Matcher matcher = pattern.matcher(text);
    if (matcher.find()) {
     output.collect(key, value);
    }
   }
}

private HadoopGrep () {
} // singleton

public static void main(String[] args) throws Exception {
  
   JobConf grepJob = new JobConf(HadoopGrep. class );
   grepJob.setJobName( " grep-search " );
   grepJob.set( " mapred.mapper.regex " , args[ 2 ]);

   grepJob.setInputPath( new Path(args[ 0 ]));
   grepJob.setOutputPath( new Path(args[ 1 ]));
   grepJob.setMapperClass(RegMapper. class );
   grepJob.setReducerClass(IdentityReducer. class );
      
   JobClient.runJob(grepJob);
}
}

        RegMapper类的configure()函数接受由main函数传入的查找字符串，map() 函数进行正则匹配，key是行数，value是文件行的内容，符合的文件行放入中间结果。
        main()函数定义由命令行参数传入的输入输出目录和匹配字符串，Mapper函数为RegMapper类，Reduce函数是什么都不做，直接把中间结果输出到最终结果的的IdentityReducer类，运行Job。


        整个代码非常简单，丝毫没有分布式编程的任何细节。

          三.运行Hadoop程序

         Hadoop这方面的文档写得不全面，综合参考GettingStartedWithHadoop 与Nutch Hadoop Tutorial 两篇后，再碰了很多钉子才终于完整的跑起来了，记录如下：     

3.1 local运行模式

       完全不进行任何分布式计算，不动用任何namenode,datanode的做法，适合一开始做调试代码。
  3.2 单机集群运行模式，伪分布式模式
   将编译好的HadoopGrep与RegMapper.class 放入hadoop/build/classes/demo/hadoop/目录
   现在将待查找的log文件放入hdfs,。
     执行hadoop/bin/hadoop dfs 可以看到它所支持的文件操作指令。
     执行hadoop/bin/hadoop dfs put log文件所在目录 in ，则log文件目录已放入hdfs的/user/user-name/in 目录中
  现在来执行Grep操作hadoop/bin/hadoop demo.hadoop.HadoopGrep in out
     查看hadoop/logs/里的运行日志，重新执行前。运行hadoop/bin/hadoop dfs rmr out 删除out目录。
     运行hadoop/bin/stop-all.sh 结束
3.3 集群运行模式

  
    四、效率

   经测试，Hadoop并不是万用灵丹，很取决于文件的大小和数量，处理的复杂度以及群集机器的数量，相连的带宽，当以上四者并不大时，hadoop优势并不明显。
   比如，不用hadoop用java写的简单grep函数处理100M的log文件只要4秒，用了hadoop local的方式运行是14秒，用了hadoop单机集群的方式是30秒，用双机集群10M网口的话更慢，慢到不好意思说出来的地步。

另外一个程序例子：

package org;  
  
import java.io.IOException;  
import java.util.StringTokenizer;  
  
import org.apache.hadoop.io.IntWritable;  
import org.apache.hadoop.io.Text;  
import org.apache.hadoop.mapreduce.Mapper;  
  
public class MyMap extends Mapper<Object, Text, Text, IntWritable> {  
    private final static IntWritable one = new IntWritable(1);  
  
    private Text word;  
  
    public void map(Object key, Text value, Context context)  
            throws IOException, InterruptedException {  
  
        String line = value.toString();  
        StringTokenizer tokenizer = new StringTokenizer(line);  
        while (tokenizer.hasMoreTokens()) {  
            word = new Text();  
            word.set(tokenizer.nextToken());  
            context.write(word, one);  
        }  
    }  
} 

    package org;  
      
    import java.io.IOException;  
      
    import org.apache.hadoop.io.IntWritable;  
    import org.apache.hadoop.io.Text;  
    import org.apache.hadoop.mapreduce.Reducer;  
      
    public class MyReduce extends  
            Reducer<Text, IntWritable, Text, IntWritable> {  
        public void reduce(Text key, Iterable<IntWritable> values, Context context)  
                throws IOException, InterruptedException {  
            int sum = 0;  
            for (IntWritable val : values) {  
                sum += val.get();  
            }  
            context.write(key, new IntWritable(sum));  
        }  
    }  

    package org;  
      
    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.lib.input.FileInputFormat;  
    import org.apache.hadoop.mapreduce.lib.input.TextInputFormat;  
    import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;  
    import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;  
      
    public class MyDriver {  
      
          
        public static void main(String[] args) throws Exception,InterruptedException {  
            Configuration conf=new Configuration();  
              
           Job job=new Job(conf,"Hello Hadoop");  
             
           job.setJarByClass(MyDriver.class);           
            
           job.setMapOutputKeyClass(Text.class);      
           job.setMapOutputValueClass(IntWritable.class);  
             
           job.setOutputKeyClass(Text.class);  
           job.setOutputValueClass(IntWritable.class);  
             
           job.setMapperClass(MyMap.class);  
            job.setCombinerClass(MyReduce.class);  
            job.setReducerClass(MyReduce.class);  
              
            job.setInputFormatClass(TextInputFormat.class);            
            job.setOutputFormatClass(TextOutputFormat.class);          
              
            FileInputFormat.setInputPaths(job, new Path(args[0]));  
              
            FileOutputFormat.setOutputPath(job, new Path(args[1]));  
          // JobClient.runJob(conf);  
           job.waitForCompletion(true);  
           }  
      
    }