BigData-Notes/notes/Hadoop-MapReduce.md
2019-04-22 22:39:25 +08:00

20 KiB
Raw Blame History

分布式计算框架——MapReduce

一、MapReduce 概述
二、MapReduce 编程模型简述
三、MapReduce 编程模型详述
四、MapReduce 词频统计案例
五、词频统计案例进阶

一、MapReduce 概述

Hadoop MapReduce是一个分布式计算框架用于编写应用程序以可靠容错的方式在大型集群上并行处理大量数据多为TB级别数据集

MapReduce 作业通常将输入数据集拆分为独立的块,这些块由map任务以完全并行的方式处理。框架对map任务的输出进行排序,然后输入到reduce任务。通常,作业的输入和输出都存储在文件系统中。该框架负责调度任务,监视任务并重新执行失败的任务。

MapReduce框架专门用于<keyvalue>对,也就是说,框架将作业的输入视为一组<keyvalue>对,并生成一组<keyvalue>对作为输出。输出和输出的keyvalue都必须实现Writable 接口。

(input) <k1, v1> -> map -> <k2, v2> -> combine -> <k2, v2> -> reduce -> <k3, v3> (output)

二、MapReduce 编程模型简述

这里以词频统计为例说明MapReduce的编程模型下图为词频统计的流程图

  1. input : 读取文本文件;

  2. splitting : 将文件按照行进行拆分此时得到的K1为行数V1表示对应行的文本内容

  3. mapping : 并行将每一行按照空格进行拆分拆分得到的List(K2,V2),其中K2代表每一个单词由于是做词频统计所以其V2为1代表出现1次

  4. shuffling由于Mapping操作可能是在不同的机器上并行处理的所以需要通过shuffling将相同的数据分到同一个节点上去合并这样才能统计出最终的结果此时得到K2为每一个单词List(V2)为可迭代集合V2就是Mapping中的V2

  5. Reducing : 这里的案例是统计单词出现的总次数所以Reducing迭代List(V2),并计算其和值,最终输出。

MapReduce 编程模型中splitting shuffing操作都是由框架实现的,实际上,主要需要我们实现的是mappingreducing中的编程逻辑这也就是为何该框架叫做MapReduce的原因。

三、MapReduce 编程模型详述

3.1 InputFormat & RecordReaders

InputFormat将输出文件拆分为多个InputSplit并由RecordReaders将InputSplit转换为标准的<key,value>键值对作为map的输出。这一步的意义在于只有先进行逻辑拆分并转为标准的格式后才能为多个map提供输入进行并行处理

InputFormat 为一个抽象类,其中定义了两个抽象方法,而实际的操作则由其实现类来进行。其源码如下:

getSplits将输入文件拆分为多个InputSplit

createRecordReader: 定义RecordReader的创建方法

public abstract class InputFormat<K, V> {

  public abstract 
    List<InputSplit> getSplits(JobContext context) throws IOException, InterruptedException;
  

  public abstract 
    RecordReader<K,V> createRecordReader(InputSplit split,
                                         TaskAttemptContext context
                                        ) throws IOException, 
                                                 InterruptedException;

}

3.2 combiner

combiner是map运算后的可选操作其实际上是一个本地化的reduce操作它主要是在map计算出中间文件后做一个简单的合并重复key值的操作。

例如我们对文件里的单词频率做统计map计算时候如果碰到一个hadoop的单词就会记录为1但是这篇文章里hadoop可能会出现n多次那么map输出文件冗余就会很多因此在reduce计算前对相同的key做一个合并操作那么文件会变小。这样就提高了宽带的传输效率因为hadoop计算的宽带资源往往是计算的瓶颈也是最为宝贵的资源。

但并非所有场景都适合使用combiner使用它的原则是combiner的输入不会影响到reduce计算的最终输入例如如果计算只是求总数最大值最小值可以使用combiner但是做平均值计算使用combiner的话最终的reduce计算结果就会出错。

不使用combiner的情况

使用combiner的情况

可以看到使用combiner的时候需要传输到reducer中的数据由12keys降低到10keys。降低的幅度取决于你keys的重复率后文词频统计案例可以直观演示用combiner降低数百倍的传输量。

3.3 partitioner

partitioner可以理解成分类器按照key的不同分别将map的输出分给不同的reduce可以自定义实现。

3.4 sort & combiner

经过partitioner处理后每个key-value对都得到分配到的reduecer信息然后把记录先写入内存(In-memory buffer)。当写入内存的数据越来越多时当buffer达到一定阀值默认80M就开始执行spill溢写步骤即分成小文件写入磁盘。在写之前先对memory中每个partition进行排序in-memory sort。如果数据量大的话这个步骤会产生很多个spilled文件如果我们定义了combine那么在排序之前还会进行combine最后一个步骤就是merge把 spill 步骤产生的所有spilled filesmerge成一个大的已排序文件。merge是相同的partition之间进行。

Merge是怎样的如“aaa”从某个map task读取过来时值是5从另外一个map 读取值是8因为它们有相同的key所以得merge成group。什么是group。对于“aaa”就是像这样的{“aaa”, [5, 8, 10, …]}数组中的值就是从不同溢写文件中读取出来的然后再把这些值加起来。请注意因为merge是将多个溢写文件合并到一个文件所以可能也有相同的key存在在这个过程中如果client设置过Combiner也会使用Combiner来合并相同的key。

四、MapReduce 词频统计案例

源码下载地址:hadoop-word-count

4.1 项目简介

这里给出一个经典的案例:词频统计。统计如下样本数据中每个单词出现的次数。

Spark	HBase
Hive	Flink	Storm	Hadoop	HBase	Spark
Flink
HBase	Storm
HBase	Hadoop	Hive	Flink
HBase	Flink	Hive	Storm
Hive	Flink	Hadoop
HBase	Hive
Hadoop	Spark	HBase	Storm
HBase	Hadoop	Hive	Flink
HBase	Flink	Hive	Storm
Hive	Flink	Hadoop
HBase	Hive

为方便大家开发,我在项目源码中放置了一个工具类WordCountDataUtils,用于产生词频统计样本文件:

public class WordCountDataUtils {

    public static final List<String> WORD_LIST = Arrays.asList("Spark", "Hadoop", "HBase", 
                                                                "Storm", "Flink", "Hive");


    /**
     * 模拟产生词频数据
     *
     * @return 词频数据
     */
    private static String generateData() {
        StringBuilder builder = new StringBuilder();
        for (int i = 0; i < 1000; i++) {
            Collections.shuffle(WORD_LIST);
            Random random = new Random();
            int endIndex = random.nextInt(WORD_LIST.size()) % (WORD_LIST.size()) + 1;
            String line = StringUtils.join(WORD_LIST.toArray(), "\t", 0, endIndex);
            builder.append(line).append("\n");
        }
        return builder.toString();
    }


    /**
     * 模拟产生词频数据并输出到本地
     *
     * @param outputPath 输出文件路径
     */
    private static void generateDataToLocal(String outputPath) {
        try {
            java.nio.file.Path path = Paths.get(outputPath);
            if (Files.exists(path)) {
                Files.delete(path);
            }
            Files.write(path, generateData().getBytes(), StandardOpenOption.CREATE);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 模拟产生词频数据并输出到HDFS
     *
     * @param hdfsUrl          HDFS地址
     * @param user             hadoop用户名
     * @param outputPathString 存储到HDFS上的路径
     */
    private static void generateDataToHDFS(String hdfsUrl, String user, String outputPathString) {
        FileSystem fileSystem = null;
        try {
            fileSystem = FileSystem.get(new URI(hdfsUrl), new Configuration(), user);
            Path outputPath = new Path(outputPathString);
            if (fileSystem.exists(outputPath)) {
                fileSystem.delete(outputPath, true);
            }
            FSDataOutputStream out = fileSystem.create(outputPath);
            out.write(generateData().getBytes());
            out.flush();
            out.close();
            fileSystem.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
       //generateDataToLocal("input.txt");
       generateDataToHDFS("hdfs://192.168.0.107:8020", "root", "/wordcount/input.txt");
    }
}

4.2 WordCountMapper

/**
 * 将每行数据按照指定分隔符进行拆分
 */
public class WordCountMapper extends Mapper<LongWritable, Text, Text, IntWritable> {

    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, 
                                                                      InterruptedException {
        String[] words = value.toString().split("\t");
        for (String word : words) {
            context.write(new Text(word), new IntWritable(1));
        }
    }

}

WordCountMapper对应下图的Mapping操作这里WordCountMapper继承自Mapper类这是一个泛型类定义如下

public class Mapper<KEYIN, VALUEIN, KEYOUT, VALUEOUT> {
   ......
}
  • KEYIN : mapping输入的key的数据类型即每行的偏移量每行第一个字符在文本中的位置Long类型对应Hadoop中的LongWritable类型
  • VALUEIN : mappin输入的value的数据类型即每行数据String类型对应Hadoop中Text类型
  • KEYOUT mapping输出的key的数据类型即每个单词String类型对应Hadoop中Text类型
  • VALUEOUTmapping输出的value的数据类型即每个单词出现的次数这里用int类型对应Hadoop中IntWritable类型

在MapReduce中必须使用Hadoop定义的类型因为Hadoop预定义的类型都是可序列化可比较的所有类型均实现了WritableComparable接口。

4.3 WordCountReducer

/**
 * 进行词频统计
 */
public class WordCountReducer extends Reducer<Text, IntWritable, Text, IntWritable> {

    @Override
    protected void reduce(Text key, Iterable<IntWritable> values, Context context) throws IOException, 
                                                                                  InterruptedException {
        int count = 0;
        for (IntWritable value : values) {
            count += value.get();
        }
        context.write(key, new IntWritable(count));
    }
}

这里的key是每个单词这里的values是一个可迭代的数据类型因为shuffling输出的数据实际上是下图中所示的这样的key(1,1,1,1,1,1,1,.....)

4.4 WordCountApp

组装MapReduce作业并提交到服务器运行代码如下


/**
 * 组装作业 并提交到集群运行
 */
public class WordCountApp {


    // 这里为了直观显示参数 使用了硬编码,实际开发中可以通过外部传参
    private static final String HDFS_URL = "hdfs://192.168.0.107:8020";
    private static final String HADOOP_USER_NAME = "root";

    public static void main(String[] args) throws Exception {

        //  文件输入路径和输出路径由外部传参指定
        if (args.length < 2) {
            System.out.println("Input and output paths are necessary!");
            return;
        }

        // 需要指明hadoop用户名否则在HDFS上创建目录时可能会抛出权限不足的异常
        System.setProperty("HADOOP_USER_NAME", HADOOP_USER_NAME);

        Configuration configuration = new Configuration();
        // 指明HDFS的地址
        configuration.set("fs.defaultFS", HDFS_URL);

        // 创建一个Job
        Job job = Job.getInstance(configuration);

        // 设置运行的主类
        job.setJarByClass(WordCountApp.class);

        // 设置Mapper和Reducer
        job.setMapperClass(WordCountMapper.class);
        job.setReducerClass(WordCountReducer.class);

        // 设置Mapper输出key和value的类型
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(IntWritable.class);

        // 设置Reducer输出key和value的类型
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(IntWritable.class);

        // 如果输出目录已经存在,则必须先删除,否则重复运行程序时会抛出异常
        FileSystem fileSystem = FileSystem.get(new URI(HDFS_URL), configuration, HADOOP_USER_NAME);
        Path outputPath = new Path(args[1]);
        if (fileSystem.exists(outputPath)) {
            fileSystem.delete(outputPath, true);
        }

        // 设置作业输入文件和输出文件的路径
        FileInputFormat.setInputPaths(job, new Path(args[0]));
        FileOutputFormat.setOutputPath(job, outputPath);

        // 将作业提交到群集并等待它完成参数设置为true代表打印显示对应的进度
        boolean result = job.waitForCompletion(true);

        // 关闭之前创建的fileSystem
        fileSystem.close();

        // 根据作业结果,终止当前运行的Java虚拟机,退出程序
        System.exit(result ? 0 : -1);

    }
}

这里说明一下:setMapOutputKeyClasssetOutputValueClass控制reducer函数的输出类型。map函数的输出类型默认情况下和reducer函数式相同的如果不同则必须通过setMapOutputKeyClasssetMapOutputValueClass进行设置。

4.5 提交到服务器运行

在实际开发中可以在本机配置hadoop开发环境直接运行main方法既可。这里主要介绍一下打包提交到服务器运行:

由于本项目没有使用除Hadoop外的第三方依赖直接打包即可

# mvn clean package

使用以下命令运行作业:

hadoop jar /usr/appjar/hadoop-word-count-1.0.jar \
com.heibaiying.WordCountApp \
/wordcount/input.txt /wordcount/output/WordCountApp

作业完成后查看HDFS上生成目录

# 查看目录
hadoop fs -ls /wordcount/output/WordCountApp

# 查看统计结果
hadoop fs -cat /wordcount/output/WordCountApp/part-r-00000

五、词频统计案例进阶

5.1 combiner

1. combiner的代码实现

combiner的代码实现比较简单只要在组装作业时添加下面一行代码即可

// 设置Combiner
job.setCombinerClass(WordCountReducer.class);

2. 测试结果

加入combiner后统计结果是不会有变化的但是我们可以从打印的日志看出combiner的效果

没有加入combiner的打印日志

加入combiner后的打印日志如下。

这里我们只有一个输入文件并且小于128M所以只有一个Map进行处理可以看到经过combiner后records由3519降低为6样本中单词种类就只有6个这一点从图中日志的reduce input records参数也可以看出来。在这个用例中combiner的效果就非常明显。

5.2 Partitioner

1. 默认Partitioner规则

这里假设有个需求:将不同单词的统计结果输出到不同文件。这种需求实际上比较常见,比如统计产品的销量时,需要将结果按照产品分类输出。

要实现这个功能就需要用到自定义Partitioner这里我们先说一下默认的分区规则在构建job时候如果不指定默认的使用的是HashPartitioner,其实现如下:

public class HashPartitioner<K, V> extends Partitioner<K, V> {

  public int getPartition(K key, V value,
                          int numReduceTasks) {
    return (key.hashCode() & Integer.MAX_VALUE) % numReduceTasks;
  }

}

对key进行哈希散列并对numReduceTasks取余,这里由于numReduceTasks默认值为1所以我们之前的统计结果都输出到同一个文件中。

2. 自定义Partitioner

这里我们继承Partitioner自定义分区规则,这里按照单词进行分区:

/**
 * 自定义partitioner,按照单词分区
 */
public class CustomPartitioner extends Partitioner<Text, IntWritable> {

    public int getPartition(Text text, IntWritable intWritable, int numPartitions) {
        return WordCountDataUtils.WORD_LIST.indexOf(text.toString());
    }
}

并在构建job时候指定使用我们自己的分区规则并设置reduce的个数

// 设置自定义分区规则
job.setPartitionerClass(CustomPartitioner.class);
// 设置reduce个数
job.setNumReduceTasks(WordCountDataUtils.WORD_LIST.size());

3. 测试结果

测试结果如下分别生成6个文件每个文件中为对应单词的统计结果。

参考资料

  1. 分布式计算框架MapReduce
  2. Apache Hadoop 2.9.2 > MapReduce Tutorial
  3. MapReduce - Combiners