一、MapReduce概述
MapReduce 是 Hadoop 的核心组成, 是专用于进行数据计算的，是一种分布式计算模型。由Google提出，主要用于搜索领域，解决海量数据的计算问题.
MapReduce由两个阶段组成：Map和Reduce，用户仅仅须要实现map()和reduce()两个函数。就可以实现分布式计算。非常easy。这两个函数的形參是key、value对，表示函数的输入输出信息。
map、reduce键值对格式
二、MapReduce体系结构及工作流程
1、JobTracker
负责接收用户提交的作业。负责启动、跟踪任务运行。
JobSubmissionProtocol是JobClient与JobTracker通信的接口。
InterTrackerProtocol是TaskTracker与JobTracker通信的接口。
2、TaskTracker
负责运行任务。
3、JobClient
是用户作业与JobTracker交互的主要接口。
负责提交作业的，负责启动、跟踪任务运行、訪问任务状态和日志等。
4、工作流程图
运行步骤：
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的输出保存到文件里。
三、统计单词源代码及凝视
package mapreduce;
import java.io.IOException;
import java.net.URI;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.LongWritable;
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;
public class WordCountApp {
static final String INPUT_PATH = "hdfs://liguodong:9000/hello";
static final String OUT_PATH = "hdfs://liguodong:9000/out";
public static void main(String[] args) throws Exception {
Configuration conf = new Configuration();
final FileSystem fileSystem = FileSystem.get(new URI(INPUT_PATH),conf);
if(fileSystem.exists(new Path(OUT_PATH)))
{
fileSystem.delete(new Path(OUT_PATH),true);
}
final Job job = new Job(conf, WordCountApp.class.getSimpleName());
//1.1 输入文件夹在哪里
FileInputFormat.setInputPaths(job, INPUT_PATH);
//指定对输入数据进行格式化处理的类
//job.setInputFormatClass(TextInputFormat.class);
//1.2 指定自己定义的Mapper类
job.setMapperClass(MyMapper.class);
//指定map的输出的<k,v>类型,假设<k3,v3>的类型与<k2,v2>的类型一致，那么能够省略。
//job.setMapOutputKeyClass(Text.class);
//job.setMapOutputValueClass(LongWritable.class);
//1.3分区
//job.setPartitionerClass(HashPartitioner.class);
//job.setNumReduceTasks(1);
//1.4 TODO 排序、分组
//1.5 TODO （可选）归约
//2.2 指定自己定义的Reducer类
job.setReducerClass(MyReducer.class);
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(LongWritable.class);
//2.3 指定输出的路径
FileOutputFormat.setOutputPath(job, new Path(OUT_PATH));
//指定输出的格式化类
//job.setOutputFormatClass(TextOutputFormat.class);
//把作业交给JobTracker运行
job.waitForCompletion(true);
}
/**
* KEYIN 即K1 表示每一行的起始位置（偏移量offset）
* VALUEIN 即v1 表示每一行的文本内容
* KEYOUT 即k2 表示每一行中的每一个单词
* VALUEOUT 即v2 表示每一行中的每一个单词的出现次数，固定值1
* @author liguodong
* Java Hadoop
* Long LongWritable
* String Text
*/
static class MyMapper extends Mapper<LongWritable,Text,Text,LongWritable>{
@Override
protected void map(LongWritable key, Text value,
Mapper<LongWritable, Text, Text, LongWritable>.Context context)
throws IOException, InterruptedException {
final String[] splited = value.toString().split(" ");
for (String word : splited) {
context.write(new Text(word), new LongWritable(1));
}
}
}
/**
* KEYIN 即k2 表示每一行中的每一个单词
* VALUEIN 即v2 表示每一行中每一个单词出现次数，固定值1
* KEYOUT 即k3 表示整个文件里的不同单词
* VALUEOUT 即v3 表示整个文件里的不同单词的出现总次数
* @author liguodong
*/
static class MyReducer extends Reducer<Text, LongWritable,Text, LongWritable>{
@Override
protected void reduce(Text k2, Iterable<LongWritable> v2s,
Reducer<Text, LongWritable, Text, LongWritable>.Context context)
throws IOException, InterruptedException {
long sum = 0L;
for (LongWritable v2 : v2s) {
sum += v2.get();
}
context.write(k2, new LongWritable(sum));
}
}
}
四、最小的MapReduce驱动
Configuration configuration = new Configuration();
Job job = new Job(configuration, "HelloWorld");
job.setInputFormat(TextInputFormat.class);
job.setMapperClass(IdentityMapper.class);
job.setMapOutputKeyClass(LongWritable.class);
job.setMapOutputValueClass(Text.class);
job.setPartitionerClass(HashPartitioner.class);
job.setNumReduceTasks(1);
job.setReducerClass(IdentityReducer.class);
job.setOutputKeyClass(LongWritable.class);
job.setOutputValueClass(Text.class);
job.setOutputFormat(TextOutputFormat.class);
job.waitForCompletion(true);五、MapReduce驱动默认的设置
六、Hadoop序列化与基本类型
1、序列化概念
序列化（Serialization）是指把结构化对象转化为字节流。
反序列化（Deserialization）是序列化的逆过程。即把字节流转回结构化对象。
Java序列化（java.io.Serializable）
2、Hadoop序列化格式特点
紧凑：高效使用存储空间。
高速：读写数据的额外开销小
可扩展：可透明地读取老格式的数据
互操作：支持多语言的交互
Hadoop的序列化格式：Writable
3、Hadoop序列化的作用
序列化在分布式环境的两大作用：进程间通信。永久存储。
Hadoop节点间通信。
4、基本数据类型
Hadoop的数据类型要求必须实现Writable接口。
Writable接口是依据 DataInput 和 DataOutput 实现的简单、有效的序列化对象.
MR的随意Key和Value必须实现Writable接口。
public interface Writable {
/**
* Serialize the fields of this object to <code>out</code>.
*
* @param out <code>DataOuput</code> to serialize this object into.
* @throws IOException
*/
void write(DataOutput out) throws IOException;
/**
* Deserialize the fields of this object from <code>in</code>.
*
* <p>For efficiency, implementations should attempt to re-use storage in the
* existing object where possible.</p>
*
* @param in <code>DataInput</code> to deseriablize this object from.
* @throws IOException
*/
void readFields(DataInput in) throws IOException;
}MR的随意key必须实现WritableComparable接口。
/**
* A {@link Writable} which is also {@link Comparable}.
*
* <p><code>WritableComparable</code>s can be compared to each other, typically
* via <code>Comparator</code>s. Any type which is to be used as a
* <code>key</code> in the Hadoop Map-Reduce framework should implement this
* interface.</p>
**/
public interface WritableComparable<T> extends Writable, Comparable<T> {
}实现Writable接口？
write 是把每一个对象序列化到输出流
readFields 是把输入流字节反序列化
实现WritableComparable？
Java值对象的比較：一般须要重写toString(),hashCode(),equals()方法。
Hadoop与Java常见基本类型的对比
Long—LongWritable
Integer—IntWritable
Boolean—BooleanWritable
String—Text
Text一般觉得它等价于java.lang.String的Writable。
针对UTF-8序列。
例:
Text test = new Text(“test”);
IntWritable one = new IntWritable(1);
java类型怎样转化为hadoop基本类型？
调用hadoop类型的构造方法，或者调用set()方法。
new LongWritable(123L);
hadoop基本类型怎样转化为java类型？
对于Text，须要调用toString()方法，其它类型调用get()方法。
七、基于文件存储的数据结构
SequenceFile—无序存储
MapFile—会对key建立索引文件，value按key顺序存储
基于MapFile的结构有:
ArrayFile—与我们使用的数组一样，key值为序列化的数字
SetFile—仅仅有key，value为不可变的数据
BloomMapFile—在 MapFile 的基础上添加了一个/bloom 文件，包括的是二进制的过滤表。在每一次写操作完毕时，会更新这个过滤表。
八、自己定义数据类型源代码
package mapreduce;
import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.io.Writable;
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.input.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;
import org.apache.hadoop.mapreduce.lib.partition.HashPartitioner;
public class KpiApp {
static final String INPUT_PATH = "hdfs://liguodong:9000/wlan";
static final String OUT_PATH = "hdfs://liguodong:9000/out";
public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
final Job job = new Job(new Configuration(),KpiApp.class.getSimpleName());
//1.1 指定输入文件路径
FileInputFormat.setInputPaths(job, INPUT_PATH);
//指定那个类用来格式化输入文件
job.setInputFormatClass(TextInputFormat.class);
//1.2 指定自己定义的Mapper类
job.setMapperClass(MyMapper.class);
//指定输出<k2,v2>的类型
job.setMapOutputKeyClass(Text.class);
job.setMapOutputValueClass(KpiWritable.class);
//1.3 指定分区类
job.setPartitionerClass(HashPartitioner.class);
job.setNumReduceTasks(1);
//1.4 TODO 排序、分组
//1.5 TODO （可选）归约
//2.2 指定自己定义的Reducer类
job.setReducerClass(MyReducer.class);
//指定输入<k3,v3>的值
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(KpiWritable.class);
//2.3 指定输出到哪里
FileOutputFormat.setOutputPath(job, new Path(OUT_PATH));
//设定输出文件的格式化类
job.setOutputFormatClass(TextOutputFormat.class);
//把任务及交给JobTrack运行
job.waitForCompletion(true);
}
static class MyMapper extends Mapper<LongWritable, Text, Text, KpiWritable>{
@Override
protected void map(LongWritable key, Text value,
Mapper<LongWritable, Text, Text, KpiWritable>.Context context)
throws IOException, InterruptedException {
final String[] splited = value.toString().split("\t");
final String msisdn = splited[1];
final Text k2 = new Text(msisdn);
final KpiWritable v2 = new KpiWritable(splited[6],splited[7],splited[8],splited[9]);
context.write(k2, v2);
}
}
static class MyReducer extends Reducer<Text, KpiWritable, Text, KpiWritable>{
/**
* @param k2 表示整个文件里不同的手机号码
* @param v2表示该手机号在不同一时候段的流量的集合
* @param
*/
@Override
protected void reduce(Text k2, Iterable<KpiWritable> v2s,
Reducer<Text, KpiWritable, Text, KpiWritable>.Context context)
throws IOException, InterruptedException {
long upPackNum = 0L;
long downPackNum = 0L;
long upPayLoad = 0L;
long downPayLoad = 0L;
for (KpiWritable kpiWritable : v2s) {
upPackNum += kpiWritable.upPackNum;
downPackNum += kpiWritable.downPackNum;
upPayLoad += kpiWritable.upPayLoad;
downPayLoad += kpiWritable.downPayLoad;
}
final KpiWritable v3 = new KpiWritable(upPackNum+"",downPackNum+"",upPayLoad+"",downPayLoad+"");
context.write(k2, v3);
}
}
}
class KpiWritable implements Writable{
long upPackNum;
long downPackNum;
long upPayLoad;
long downPayLoad;
public KpiWritable(){
}
public KpiWritable(String upPackNum, String downPackNum, String upPayLoad,
String downPayLoad) {
super();
this.upPackNum = Long.parseLong(upPackNum);
this.downPackNum = Long.parseLong(downPackNum);
this.upPayLoad = Long.parseLong(upPayLoad);
this.downPayLoad = Long.parseLong(downPayLoad);
}
@Override
public void write(DataOutput out) throws IOException {
out.writeLong(upPackNum);
out.writeLong(downPackNum);
out.writeLong(upPayLoad);
out.writeLong(downPayLoad);
}
@Override
public void readFields(DataInput in) throws IOException {
this.upPackNum = in.readLong();
this.downPackNum = in.readLong();
this.upPayLoad = in.readLong();
this.downPayLoad = in.readLong();
}
@Override
public String toString(){
return upPackNum+"\t"+downPackNum+"\t"+upPayLoad+"\t"+downPayLoad;
}
}
九、MapReduce输入输出处理类
1、输入处理类
FileInputFormat:
FileInputFormat是全部以文件作为数据源的InputFormat实现的基类，FileInputFormat保存作为job输入的全部文件。并实现了对输入文件计算splits的方法。至于获得记录的方法是有不同的子类——TextInputFormat进行实现的。
InputFormat 负责处理MR的输入部分.
有三个作用:
验证作业的输入是否规范.
把输入文件切分成InputSplit.
提供RecordReader 的实现类，把InputSplit读到Mapper中进行处理.
public abstract class InputFormat<K, V> {
/**
* Logically split the set of input files for the job.
*
* <p>Each {@link InputSplit} is then assigned to an individual {@link Mapper}
* for processing.</p>
*
* <p><i>Note</i>: The split is a <i>logical</i> split of the inputs and the
* input files are not physically split into chunks. For e.g. a split could
* be <i><input-file-path, start, offset></i> tuple. The InputFormat
* also creates the {@link RecordReader} to read the {@link InputSplit}.
*
* @param context job configuration.
* @return an array of {@link InputSplit}s for the job.
*/
public abstract
List<InputSplit> getSplits(JobContext context
) throws IOException, InterruptedException;
/**
* Create a record reader for a given split. The framework will call
* {@link RecordReader#initialize(InputSplit, TaskAttemptContext)} before
* the split is used.
* @param split the split to be read
* @param context the information about the task
* @return a new record reader
* @throws IOException
* @throws InterruptedException
*/
public abstract
RecordReader<K,V> createRecordReader(InputSplit split,
TaskAttemptContext context
) throws IOException,
InterruptedException;
}InputSplit
在运行mapreduce之前。原始数据被切割成若干split。每一个split作为一个map任务的输入，在map运行过程中split会被分解成一个个记录（key-value对），map会依次处理每一个记录。
FileInputFormat仅仅划分比HDFS block大的文件，所以FileInputFormat划分的结果是这个文件或者是这个文件里的一部分。
假设一个文件的大小比block小，将不会被划分，这也是Hadoop处理大文件的效率要比处理非常多小文件的效率高的原因。
当Hadoop处理非常多小文件（文件大小小于hdfs block大小）的时候。因为FileInputFormat不会对小文件进行划分，所以每一个小文件都会被当做一个split并分配一个map任务，导致效率底下。
比如：一个1G的文件，会被划分成16个64MB的split，并分配16个map任务处理。而10000个100kb的文件会被10000个map任务处理。
TextInputFormat
TextInputformat是默认的处理类，处理普通文本文件。
文件里每一行作为一个记录，他将每一行在文件里的起始偏移量作为key，每一行的内容作为value。
默认以\n或回车键作为一行记录。
TextInputFormat继承了FileInputFormat。
其它输入类
◆ CombineFileInputFormat
相对于大量的小文件来说，hadoop更合适处理少量的大文件。
CombineFileInputFormat能够缓解这个问题，它是针对小文件而设计的。
◆ KeyValueTextInputFormat
当输入数据的每一行是两列。并用tab分离的形式的时候，KeyValueTextInputformat处理这样的格式的文件非常适合。
◆ NLineInputformat
NLineInputformat能够控制在每一个split中数据的行数。
◆ SequenceFileInputformat
当输入文件格式是sequencefile的时候，要使用SequenceFileInputformat作为输入。
InputFormat类的层次结构
2、输出处理类
TextOutputformat
默认的输出格式，key和value中间值用tab隔开的。
SequenceFileOutputformat
将key和value以sequencefile格式输出。
SequenceFileAsBinaryOutputFormat
将key和value以原始二进制的格式输出。
MapFileOutputFormat
将key和value写入MapFile中。
因为MapFile中的key是有序的，所以写入的时候必须保证记录是按key值顺序写入的。
MultipleOutputFormat
默认情况下一个reducer会产生一个输出。可是有些时候我们想一个reducer产生多个输出，MultipleOutputFormat和MultipleOutputs能够实现这个功能。
OutputFormat类的层次结构
3、自己定义输入类格式
1）继承FileInputFormat基类。
2）重写里面的getSplits(JobContext context)方法。
3）重写createRecordReader(InputSplit split,TaskAttemptContext context)方法。
