Hadoop1.1.2学习笔记（5）

MapReduce是一种分布式计算模型，由Google提出，主要用于搜索领域，解决海量数据的计算问题.

MR由两个阶段组成：Map和Reduce，用户只需要实现map()和reduce()两个函数，即可实现分布式计算，非常简单。

这两个函数的形参是key、value对，表示函数的输入信息。

执行步骤：

1. map任务处理

1.1 读取输入文件内容，解析成key、value对。对输入文件的每一行，解析成key、value对。每一个键值对调用一次map函数。

1.2 写自己的逻辑，对输入的key、value处理，转换成新的key、value输出。

1.3 对输出的key、value进行分区。

1.4 对不同分区的数据，按照key进行排序、分组。相同key的value放到一个集合中。

1.5 (可选)分组后的数据进行归约。

2.reduce任务处理

2.1 对多个map任务的输出，按照不同的分区，通过网络copy到不同的reduce节点。

2.2 对多个map任务的输出进行合并、排序。写reduce函数自己的逻辑，对输入的key、value处理，转换成新的key、value输出。

2.3 把reduce的输出保存到文件中。

简单的计数程序：

/**
 * wordcount.txt文件内容：
 * hello you 
 * hello me
 * 需求，统计每个单词出现的次数
 * 
 * 最后输出结果查看hdfs://hadoop2:9000/out 下的part-r-00000输出文件结果为
 * hello 	2
 * me 		1
 * you 		1
 * @author yinhao
 *
 */
public class WordCountApp {
	//分别读取的文件和统计结果输出的路径
	public static final String INPUT_PATH = "hdfs://hadoop2:9000/wordcount.txt"; 
	public static final String OUT_PATH = "hdfs://hadoop2:9000/out"; 
	public static void main(String[] args) throws Exception {
		Configuration conf = new Configuration();
		//读取wordcount.txt
		FileSystem fileSystem = FileSystem.get(new URI(INPUT_PATH), conf);
		//如果输出目录已存在删除已有目录
		if(fileSystem.exists(new Path(OUT_PATH))){
			fileSystem.delete(new Path(OUT_PATH), true);
		}
		
		Job job = new Job(conf, WordCountApp.class.getSimpleName());
		//1.1 读取数据 并指定对输入数据进行格式化处理的类
		FileInputFormat.setInputPaths(job, INPUT_PATH);
		job.setInputFormatClass(TextInputFormat.class);
		//1.2 指定自定义的mapper类 指定mapper输出的键值类型
		job.setMapperClass(MyMapper.class);
		job.setMapOutputKeyClass(Text.class);
		job.setMapOutputValueClass(LongWritable.class);
		//1.3 分区 并指定reduce任务的数量
		job.setPartitionerClass(HashPartitioner.class);
		job.setNumReduceTasks(1);
		//1.4 排序、分组
		
		//1.5 规约
		
		//2.1 
		
		//2.2 指定定义的reducer
		job.setReducerClass(MyReduce.class);
		job.setOutputKeyClass(Text.class);
		job.setOutputValueClass(LongWritable.class);
		//2.3 指定输出路径 并指定对输出数据进行格式化处理的类
		FileOutputFormat.setOutputPath(job, new Path(OUT_PATH));
		job.setOutputFormatClass(TextOutputFormat.class);
		
		job.waitForCompletion(true);
	}

	/**
	 * KEYIN 读取文件的每一行的起始位置或称为偏移量 
	 * VALUEIN 每一行的内容 
	 * KEYOUT 每一行中的每个单词 
	 * VALUEOUT 每一行中每个单词的统计次数 均为1 ("word",1)
	 * 
	 * @author yinhao
	 * 
	 */
	static class MyMapper extends
			Mapper<LongWritable, Text, Text, LongWritable> {
		protected void map(
				LongWritable key,
				Text value,
				org.apache.hadoop.mapreduce.Mapper<LongWritable, Text, Text, LongWritable>.Context context)
				throws java.io.IOException, InterruptedException {
			//将每一行内容转换成String类型
			String line = value.toString();
			//将每行文本中的单词拆分成数组
			String[] splited = value.toString().split(" ");
			//统计每个单词，出现次数均为1次
			for (String word : splited) {
				context.write(new Text(word), new LongWritable(1l));
			}
		};
	}

	/**
	 * 
	 * KEYIN 整个文件不同的单词 
	 * VALUEIN 经过按相同的key分组之后，将相同key的键作为key，相同key的value添加集合中形成新的value 本例为：("hello":{1,1}）
	 * KEYOUT 整个文件中不同的单词 
	 * VALUEOUT 整个文件中不同的单词出现总次数  本例为：("hello",2)
	 * 
	 */
	static class MyReduce extends
			Reducer<Text, LongWritable, Text, LongWritable> {
		/**
		 * text 整个文件不同的单词 
		 * values 整个文件不同的单词出现次数的集合 集合中的每个元素都是1  本例为：("hello":{1,1}）
		 * 
		 */
		protected void reduce(
				Text text,
				java.lang.Iterable<LongWritable> values,
				org.apache.hadoop.mapreduce.Reducer<Text, LongWritable, Text, LongWritable>.Context context)
				throws java.io.IOException, InterruptedException {
			Long count = 0l;
			//遍历分组后的values进行统计，将最终计数结果输出
			for (LongWritable value : values) {
				count += value.get();
			}
			context.write(text, new LongWritable(count));
		};
	}

}