MapReduce出现oom

MapReduce的学习从以下几个方面展开

1.1 MapReduce定义

MapReduce是一个分布式运算程序的编程框架，是用户开发“基于Hadoop的数据分析应用”的核心框架。

MapReduce核心功能适将用户编写的业务逻辑代码和自带默认组件整合成一个完整的分布式运算程序，并发运行在一个Hadoop集群上。

1.2 MapReduce优缺点

1.2.1 优点

1. 易于编程。用户只关系业务逻辑，实现框架的接口；
2. 良好的扩展性。可以动态的增加服务器，解决计算资源不够的问题；
3. 高容错性。任何一台机器挂掉，可以将任务转移到其他节点；
4. 适合海量数据的计算（TB/PB），几千台服务器共同计算。

1.2.2 缺点

1. 不擅长实时计算，毫秒，秒级别的计算；
2. 不擅长流式计算；
3. 不擅长DAG有向无环图计算

1.3 MapReduce核心思想 

1.4 MapReduce进程

一个完整的MapReduce程序在分布式运行时有三类实例进程：

1. MrAppMaster：负责整个程序的过程调度及状态协调；
2. MapTask：负责Map阶段的整个数据处理流程；
3. ReduceTask：负责Reduce阶段的整个数据处理流程

1.5 官方wordCount源码

采用反编译工具反编译源码。wordCount案例有Map类、Reduce类和驱动类。且数据类型是Hadoop自身封装的序列化类型。

1.6 常用的数据序列化类型

Java类型	Hadoop Writable类型
Boolean	BooleanWritable
Byte	ByteWritable
Int	IntWritable
Float	FloatWritable
Long	LongWritable
Double	DoubleWritable
String	Text
Map	MapWritable
Array	ArrayWritable
Null	NullWritable

1.7 MapReduce编程规范

用户编写的程序分成三个部分：Mapper、Reducer和Driver

• Mapper阶段

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

• Reducer阶段

6. 用户自定义的Reducer要继承自己的父类；
7. Reducer的输入数据类型对应Mapper的输出数据类型，也是KV；
8. Reducer的业务逻辑写在reduce()方法中；
9. ReduceTask进程对每一组相同k的<k,v>组调用一次reduce()方法；

• Driver阶段

相当于YARN集群的客户端，用于提交我们整个程序到YARN集群，提交的是封装了MapReduce程序相关运行参数的job对象

1.8 wordCount案例实操

1.8.1 本地测试

需求：统计一堆文件中单词出现的个数

• 环境准备

1. 创建maven工程，MapReduceDemo
2. 在pom.xml文件中添加如下依赖

<dependencies>
    <dependency>
        <groupId>org.apache.hadoop</groupId>
        <artifactId>hadoop-client</artifactId>
        <version>3.1.0</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-log4j12</artifactId>
        <version>1.7.30</version>
    </dependency>
</dependencies>

1. 在项目的src/main/resources目录下，新建一个文件，命名为“log4j.properties”，在文件中填入以下内容

log4j.rootLogger=INFO, stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern =  %d %p [%c] - %m%n
log4j.appender.logfile=org.apache.log4j.FileAppender
log4j.appender.logfile.File=target/spring.log
log4j.appender.logfile.layout=org.apache.log4j.PatternLayout
log4j.appender.logfile.layout.ConversionPattern =  %d %p [%c] - %m%n

1. 创建包名：com.atguigu.mapreduce.wordcount

• 编写程序

在包下面创建WordCountMapper、WordCountReducer、WordCountDriver

package com.atguigu.mapreduce.wordcount;


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;

/**
 * @date 2021/05/27
 **/

/**
 * KEYIN，map阶段输入的key的类型：LongWritable
 * VALUEIN，map阶段输入value类型：Text
 * KEYOUT，map阶段输出的key类型：Text
 * VALUEOUT，map阶段输出的value类型：IntWritable
 */
public class WordCountMapper extends Mapper<LongWritable, Text, Text, IntWritable> {
    private Text outK = new Text();
    private IntWritable outV = new IntWritable(1);
    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        // 1.获取一行
        String line = value.toString();
        // 2.切割
        // atguigu
        // atguigu
        String[] words = line.split(" ");
        // 3.循环写出
        for (String word : words) {
            //封装
            outK.set(word);
            //写出
            context.write(outK,outV);
        }
        super.map(key, value, context);
    }
}

package com.atguigu.mapreduce.wordcount;

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

import java.io.IOException;

/**
 * @date 2021/05/27
 **/
/**
 * KEYIN，reduce阶段输入的key的类型：Text
 * VALUEIN，reduce阶段输入value类型：IntWritable
 * KEYOUT，reduce阶段输出的key类型：Text
 * VALUEOUT，reduce阶段输出的value类型：IntWritable
 */
public class WordCountReducer extends Reducer<Text, IntWritable, Text, IntWritable> {
    private IntWritable outV = new IntWritable();

    @Override
    protected void reduce(Text key, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException {
        int sum = 0;
        // atguigu,(1,1)
        // 累加
        for (IntWritable value : values) {
            sum += value.get();
        }
        outV.set(sum);
        //写出
        context.write(key,outV);
    }
}

package com.atguigu.mapreduce.wordcount;

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.output.FileOutputFormat;

import java.io.IOException;


/**
 * @author
 * @date 2021/05/27
 **/
public class WordCountDriver {

    public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
        //1.获取job
        Configuration conf = new Configuration();
        Job job = Job.getInstance(conf);

        //2.获取jar包路径
        job.setJarByClass(WordCountDriver.class);

        //3.关联mapper，关联reducer
        job.setMapperClass(WordCountMapper.class);
        job.setReducerClass(WordCountReducer.class);

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

        //5.设置最终输出的kv类型
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(IntWritable.class);

        //6.设置输入路径和输出路径
        FileInputFormat.setInputPaths(job, new Path("F:\\IdeaProject\\MapReduceDemo\\input"));
        FileOutputFormat.setOutputPath(job, new Path("F:\\IdeaProject\\MapReduceDemo\\output"));

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

1.8.2 提交到集群测试

1. 打包对应的插件依赖，第二个plugin会将所有的依赖包都打包进去
2. 修改传参，将wc.jar包上传到集群，new Path(args[0])，new Path(args[1])
3. 执行，在hadoop102上，hadoop jar wc.jar com.atguigu.mapreduce.wordcount2.WordCountDriver /input /output