yarn/mapreduce工作机制及mapreduce客户端代码编写

首先需要知道的就是在老版本的hadoop中是没有yarn的，mapreduce既负责资源分配又负责业务逻辑处理。为了解耦，把资源分配这块抽了出来，形成了yarn，这样不仅mapreudce可以用yarn，其他运算体系也可以用yarn，比如说storm、spark。

把我们编写好的符合mapreduce编程规范的代码打成jar包，上传到ResourceManager节点。执行 hadoop jar xxx.jar  mainClass(这里用mainClass代表main类) 后，会有一个RunJar进程向ResourceManager节点申请执行此job，ResourceManager会返回该job相关资源提交的路径和为此job分配的jobID。RunJar进程会向把资源提交到指定目录并向ResourceManager汇报提交结果。ResourceManager收到提交结果，如果提交结果为成功的话，则把本job加入到任务队列中。NodeManager会定期扫描任务队列，如果发现需要自己参与的任务，则领取该任务，并给此任务分配一定的资源(内存、cpu等)。之后就该MapReduce框架发挥作用了(mapreduce程序需要先执行map再执行reduce，而yarn是不关心这些的，解耦)，MapReduce会产生一个MRAppMaster进程来管理map程序和reduce程序的执行。

mapreduce客户端程序编写：

先引入jar包，同hdfs客户端程序编写一样，还是只引入hadoop-client依赖即可，如下

<!-- https://mvnrepository.com/artifact/org.apache.hadoop/hadoop-client -->
<dependency>
    <groupId>org.apache.hadoop</groupId>
    <artifactId>hadoop-client</artifactId>
    <version>2.7.4</version>
</dependency>

这样项目中就有了yarn相关jar包(hadoop-yarn-api-2.7.4.jar、hadoop-yarn-client-2.7.4.jar、hadoop-yarn-common-2.7.4.jar、hadoop-yarn-server-common-2.7.4.jar)和mapreduce相关jar包(hadoop-mapreduce-client-app-2.7.4.jar、hadoop-mapreduce-client-common-2.7.4.jar、hadoop-mapreduce-client-core-2.7.4.jar、hadoop-mapreduce-client-jobclient-2.7.4.jar、hadoop-mapreduce-client-shuffle-2.7.4.jar)。

mapreduce程序需要分为map和reduce，还要用一个main类，在main方法中把同一个job的map和reduce绑定起来，因为很可能有多个map和reudce。

下面以一个小需求为例来编写入门代码：

需求：在hdfs上 /logs/ 目录下有很多很大的日志文件，统计一下在这些日志文件中出现的单词及每个单词出现的次数。

map类代码：

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

import java.util.Arrays;

public class WCMapper extends Mapper<LongWritable, Text, Text, LongWritable> {
    private Log LOGGER = LogFactory.getLog(getClass());

    //mapreduce框架每读一行数据就调用一次本方法，key是这一行数据的偏移量，value是这一行的文本内容
    @Override
    protected void map(LongWritable key, Text value, Context context) {
        //逐个输出为key value形式，key 是单词，value是1
        Arrays.asList(value.toString()).stream().map(Text::new).forEach(w -> {
            try {
                context.write(w, new LongWritable(1));
            } catch (Exception e) {
                LOGGER.error("", e);
            }
        });
    }
}

map类需要继承Mapper(org.apache.hadoop.mapreduce.Mapper，在hadoop-mapreduce-client-core-2.7.4.jar包中)，只需要实现Mapper的一个map()方法。重写的map()方法在mapreduce框架每读取一行数据时都会调用一次，第一个参数值就是这一行数据的偏移量，其实就是这一行第一个字符的在整个文档中的索引(从0开始)，第二个参数值就是这一行数据的文本内容，在map()方法中把读取到的数据按空格分割成单词数组后，再调用Mapper类的Context内部类的实例方法write()，按照键值对的方式(键是单词，值是1，其实2,3,4都行，只要是个固定的值)，一个个的传输给mapreduce框架。读取的源文件及其路径在main类中配置。

备注：LongWritable(org.apache.hadoop.io.LongWritable，在hadoop-common-2.7.4.jar中)是hadoop对long型数据的包装，Text(org.apache.hadoop.io.Text，也在hadoop-common-2.7.4.jar中)是hadoop对String类型数据的包装。

reduce类代码：

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

import java.util.Arrays;

public class WCReducer extends Reducer<Text, LongWritable, Text, LongWritable> {
    private Log LOGGER = LogFactory.getLog(getClass());

    //框架在map处理完成之后，将所有kv对缓存起来，进行分组，然后传递一个组调用一次reduce方法
    @Override
    protected void reduce(Text key, Iterable<LongWritable> values, Context context) {
        try {
            context.write(key, new LongWritable(Arrays.asList(values).size()));
        } catch (Exception e) {
            LOGGER.error("", e);
        }
    }
}

reduce类需要继承Reducer(org.apache.hadoop.mapreduce.Reducer，也在hadoop-mapreduce-client-core-2.7.4.jar包中)，也只需要实现Reducer的一个reduce()方法。mapreduce框架在所有nodemanager节点上的map()方法执行完之后，将所有的key-value对缓存起来，进行分组后作为入参传递给reduce()方法，每传递一个组就会调用一次reduce()方法(也就是说，如果文件中有100个不同的单词，就要调用100次reduce()方法)，reduce()方法执行完之后就会将结果输出到指定的文件中，文件路径在main类中配置。

main类代码：

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
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.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

/**
 * 用来描述一个特定的作业，比如该作业使用哪个类作为逻辑处理中的map，哪个作为reduce,还可以指定该作业要处理的数据所在的路径，还可以指定该作业输出的结果放到哪个路径
 */
public class WCRunner {
    private static Log LOGGER = LogFactory.getLog(WCRunner.class);

    public static void main(String[] args) throws Exception {
        try {
            LOGGER.info("HADOOP_HOME: " + System.getProperty("hadoop.home.dir"));
            Configuration conf = new Configuration();
            conf.set("fs.defaultFS", "hdfs://centos1:9000");
            //获取job实例
            Job wcJob = Job.getInstance(conf);

            //设置整个job所用的类在哪个jar包
            wcJob.setJarByClass(WCRunner.class);
            //设置map类
            wcJob.setMapperClass(WCMapper.class);
            //设置reduce类
            wcJob.setReducerClass(WCReducer.class);

            //设置job reduce类输出key的类型
            wcJob.setOutputKeyClass(Text.class);
            //设置job reduce类输出value的类型
            wcJob.setOutputValueClass(LongWritable.class);
            //设置job map类输出key的类型
            wcJob.setMapOutputKeyClass(Text.class);
            //设置job map类输出value的类型
            wcJob.setMapOutputValueClass(LongWritable.class);

            //指定要处理的原始数据存放在哪里
            FileInputFormat.setInputPaths(wcJob, "/logs/");
            //指定处理结果放在哪里
            FileOutputFormat.setOutputPath(wcJob, new Path("/wc/output/"));

            //将job提交给集群运行
            wcJob.waitForCompletion(true);
        } catch (Exception e) {
            LOGGER.error("", e);
        }
    }
}

main类在main方法中先是通过org.apache.hadoop.mapreduce.Job类的 getInstance(Configuration conf) 静态方法获取一个Job实例，然后设置这个实例的各种属性，最后再调用waitForCompletion(boolean verbose)实例方法把任务提交给集群并等待任务执行完毕。

至此，代码已写完。

把这三个类打成jar包，上传到resourceManager节点，执行命令 hadoop jar xxx.jar  mainClass。这样mapreduce就会处理hdfs /logs目录中的文件并把结果输出到hdfs /wc/output目录的某个文件中。