Hadoop学习--第七篇：初识 MapReduce

前言

Hadoop在大数据技术体系中的地位至关重要，Hadoop是大数据技术的基础。Hadoop的核心是MapReduce和HDFS。前面已经介绍了HDFS，那么这篇博客就来介绍一下MapReduce。本文主要介绍：① MapReduce的基本概念；② 以WordCount为例，介绍MapReduce的编程规范；③Hadoop的序列化。

---

一、Mapreduce 概述

1.1 Mapreduce 概念

Mapreduce是一个分布式运算程序的编程框架，是用户开发"基于hadoop的数据分析应用"的核心框架。具体详解可以参考：谷歌技术"三宝"之MapReduce，谷歌三大论文之一-MapReduce。

1.2 HDFS优缺点

1.2.1 优点

① MapReduce 易于编程。它简单的实现一些接口，就可以完成一个分布式程序。
② 良好的扩展性。节点增删容易。
③ 高容错性。比如其中一台机器挂了，它可以把上面的计算任务转移到另外一个节点上面上运行。
④ 适合 PB 级以上海量数据的离线处理。

1.2.2 缺点

① 实时计算。MapReduce 无法像 Mysql 一样，在毫秒或者秒级内返回结果。
② 流式计算。流式计算的输入数据时动态的，而 MapReduce 的输入数据集必须是静态的。
③ 有向图计算。存在依赖关系，后一个应用程序的输入为前一个的输出，会造成大量的磁盘IO，导致性能非常的低下。

1.3 核心思想

1. 分布式的运算程序往往需要分成至少2个阶段。
2. 第一个阶段的maptask并发实例，完全并行运行，互不相干。
3. 第二个阶段的reduce task并发实例互不相干，但是他们的数据依赖于上一个阶段的所有maptask并发实例的输出。
4. MapReduce编程模型只能包含一个map阶段和一个reduce阶段，如果用户的业务逻辑非常复杂，那就只能多个mapreduce程序，串行运行。

---

二、Mapreduce 编程规范

编写的程序分成三个部分：Mapper，Reducer，Driver(提交运行mr程序的客户端)。下面以 WordCount为例子阐述代码。

2.1 Mapper 阶段

1. 用户自定义的Mapper要继承自己的父类；
2. Mapper中的业务逻辑写在map()方法中（重写父类的map方法）；
3. Mapper的输入和输出数据都是是KV对的形式（KV的类型可自定义）；
4. map()方法对每一个<K,V>调用一次，即 每一行输入数据调用一次map()方法。

import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;
import java.io.IOException;

/**
 * 输入的key     LongWritable    行号
 * 输入的value   Text            一行内容
 * 输出的key     Text            单词
 * 输出的value   IntWritable     单词个数
 */
public class WordcountMapper extends Mapper<LongWritable, Text, Text, IntWritable> {
  Text k = new Text();
  IntWritable v = new IntWritable(1);

  @Override
  protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
    // 1 获取一行
    String  line = value.toString();
    // 2 切割
    String[] words = line.split(" ");
    // 3 输出
    for (String word : words) {
      k.set(word);
      context.write(k, v);
    }
  }
}

2.2 Reducer 阶段

1. 用户自定义的Reducer要继承自己的父类；
2. Reducer的业务逻辑写在reduce()方法中（重写父类的reduce方法）；
3. Reducer的输入数据类型对应Mapper的输出数据类型，也是KV；
4. Reducetask进程对每一组相同k的<k,v>组调用一次reduce()方法。

import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;
import java.io.IOException;

/**
 * 输入key    Text          map输出key
 * 输入value  IntWritable   map输出value
 */
public class WordcountReducer extends Reducer<Text, IntWritable,Text, IntWritable> {

  @Override
  protected void reduce(Text key, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException {
    // 1. 累加求和
    int sum = 0;
    for (IntWritable count : values ) {
      sum += count.get();
    }
    // 2 输出
    context.write(key, new IntWritable(sum));
  }
}

2.3 Driver 阶段

整个程序需要一个Drvier来进行提交，提交的是一个描述了各种必要信息的job对象。

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.CombineTextInputFormat;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import java.io.IOException;

/**
 * 统计一堆文件中单词出现的个数（WordCount案例）
 */
public class WordcountDriver {
  public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
    // 1 获取配置信息
    Configuration configuration = new Configuration();
    Job job = Job.getInstance(configuration);

    // 2 设置 jar 加载路径
    job.setJarByClass(WordcountDriver.class);

    // 3 设置 map 和 Reduce 类
    job.setMapperClass(WordcountMapper.class);
    job.setReducerClass(WordcountReducer.class);

    // 4 设置 map 输出
    job.setMapOutputKeyClass(Text.class);
    job.setMapOutputValueClass(IntWritable.class);

    // 5 设置 Reduce 输出
    job.setOutputKeyClass(Text.class);
    job.setOutputValueClass(IntWritable.class);

    // 6 设置输入和输出路径
    // 注意：输出路径 不需要自己创建，否则会报错
    FileInputFormat.setInputPaths(job, new Path(args[0]));
    FileOutputFormat.setOutputPath(job, new Path(args[1]));

    // 7 提交
    boolean result = job.waitForCompletion(true);
    System.exit(result ? 0 : 1);
  }
}

---

三、Hadoop 序列化

Hadoop 在集群之间进行通讯或者 RPC 调用的时候，需要序列化，而且要求序列化要快，且体积要小，占用带宽要小。

那么为什么不用Java的序列化呢？

Java 的序列化是一个重量级序列化框架（Serializable），一个对象被序列化后，会附带很多额外的信息（各种校验信息， header，继承体系等），不便于在网络中高效传输。 所以，hadoop 自己开发了一套序列化机制（Writable），精简、高效。

Hadoop自带的org.apache.hadoop.io包中有广泛的Writable类可供选择。

3.1 常用数据序列化类型

Writable类对所有Java基本类型提供封装，char类型除外（可以存储在IntWritable中）。
所有的封装包含get()和set()两个方法用于读取或才能出封装的值。
IntWritable和LongWritable还有对应的变长VIntWritable和VLongWritable类。

Java基本类型	Writable实现	序列化大小（字节）
boolean	BooleanWritable	1
byte	ByteWritable	1
short	ShortWritable	2
int	IntWritable	4
float	FloatWritable	4
long	LongWritable	8
double	DoubleWritable	8
string	Text	–
map	MapWritable	–
array	ArrayWritable	–

3.2 自定义Writable

Hadoop已经实现了一些非常有用的Writable，你还可以自定义Writable来构造一些更加复杂的结果。自定义 bean 对象要想序列化传输，必须实现序列化接口， 同时需要注意以下 ：
① 必须实现 Writable 接口；
② 反序列化时，需要反射调用空参构造函数，所以必须有空参构造；
③ 重写序列化方法：write(DataOutput out)；
④ 重写反序列化方法：readFields(DataInput in) ；
⑤ 注意反序列化的顺序和序列化的顺序完全一致；
⑥ 要想把结果显示在文件中，需要重写 toString()， 可用”\t”分开，也可以用其他。
⑦ 如果需要将自定义的 bean 放在 key 中传输，则还需要实现 comparable 接口，因为mapreduce 框中的 shuffle 过程一定会对 key 进行排序。
⑧ 同时实现Writable，comparable ，可以使用WritableComparable接口代替。

import lombok.Data;
import org.apache.hadoop.io.WritableComparable;
import org.apache.hadoop.io.WritableUtils;
import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;

@Data
public class UserWritable implements WritableComparable<UserWritable> {
  private Text name;
  private IntWritable age;

  public UserWritable() {
    set(new Text(),new IntWritable());
  }

  public UserWritable(Text name, IntWritable age) {
     set(name,age);
  }
  
  public void set(Text name,IntWritable age) {
    this.name = name;
    this.age = age;
  }

  /**
   * 序列化方法
   * @param out
   * @throws IOException
   */
  @Override
  public void write(DataOutput out) throws IOException {
    name.write(out);
    age.write(out);
  }

  /**
   * 反序列化方法
   * 注意反序列化的顺序和序列化的顺序完全一致
   * @param in
   * @throws IOException
   */
  @Override
  public void readFields(DataInput in) throws IOException {
    name.readFields(in);
    age.readFields(in);
  }

  /**
   * 自定义排序
   * @param o
   */
  @Override
  public int compareTo(UserWritable o) {
    int cmp = name.compareTo(o.getName());
    if (cmp != 0) {
      return cmp;
    }
    return age.compareTo(o.getAge());
  }

  @Override
  public String toString() {
    return name + "\t" + age ;
  }
}

---

参考

谷歌技术"三宝"之MapReduce
谷歌三大论文之一-MapReduce
Hadoop实现定制的Writeable集合