hadoop的第一个hello world程序（wordcount）

在hadoop生态中，wordcount是hadoop世界的第一个hello world程序。

wordcount程序是用于对文本中出现的词计数，从而得到词频，本例中的词以空格分隔。

关于mapper、combiner、shuffler、reducer等含义请参照Hadoop权威指南里的说明。

代码参考：https://github.com/asker124143222/wordcount

1、hadoop平台搭建

参照之前的帖子搭一个伪分布式的hadoop就可以。链接：https://www.cnblogs.com/asker009/p/9126354.html

2、新建一个普通console程序，引入maven框架。

引入hadoop核心依赖，注意hadoop平台用的3.1版本，引入的依赖尽量使用这个版本，以免出现版本兼容问题

<dependency>
    <groupId>org.apache.hadoop</groupId>
    <artifactId>hadoop-core</artifactId>
    <version>1.2.1</version>
</dependency>

<dependency>
    <groupId>org.apache.hadoop</groupId>
    <artifactId>hadoop-common</artifactId>
    <version>3.1.0</version>
</dependency>

<dependency>
    <groupId>org.apache.hadoop</groupId>
    <artifactId>hadoop-hdfs</artifactId>
    <version>3.1.0</version>
</dependency>

<dependency>
    <groupId>org.apache.hadoop</groupId>
    <artifactId>hadoop-hdfs-client</artifactId>
    <version>3.1.0</version>
    <scope>provided</scope>
</dependency>

检查版本

[hadoop@hp4411s ~]$ hadoop version
Hadoop 3.1.
Source code repository https://github.com/apache/hadoop -r 16b70619a24cdcf5d3b0fcf4b58ca77238ccbe6d
Compiled by centos on --30T00:00Z
Compiled with protoc 2.5.
From source with checksum 14182d20c972b3e2105580a1ad6990
This command was run using /opt/hadoop/hadoop-3.1./share/hadoop/common/hadoop-common-3.1..jar

3、编写mapper

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

import java.io.IOException;

/**
 * @Author: xu.dm
 * @Date: 2019/1/29 16:44
 * @Description: 读取采用空格分隔的字符，并且每个词计数为1
 */
public class WordCountMapper extends Mapper<Object, Text, Text, IntWritable> {
    @Override
    protected void map(Object key, Text value, Context context) throws IOException, InterruptedException {
        String line = value.toString();
        String[] words = line.split(" ");
        for (String word : words) {
            System.out.println(word);
            context.write(new Text(word), new IntWritable(1));
        }
    }
}

Mapper类是一个泛型类型，它有四个形参类型，分别指定map函数的输入键、输入值、输出键、输出值的类型。hadoop没有直接使用Java内嵌的类型，而是自己开发了一套可以优化网络序列化传输的基本类型。这些类型都在org.apache.hadoop.io包中。
Object类型，适用于字段需要使用多种类型的时候，Text类型相当于Java中的String类型，IntWritable类型相当于Java中的Integer类型

context它是mapper的一个内部类继承自MapContext，是为了在map或是reduce任务中跟踪task的状态，记录map执行的上下文。
在mapper类中，这个context可以存储一些job conf的信息，比如job运行时参数等，程序可以在map函数中处理这个信息，这种方式是Hadoop中参数传递中很常见，context作为了map和reduce执行中各个函数的一个桥梁。

4、编写reducer

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

import java.io.IOException;

/**
 * @Author: xu.dm
 * @Date: 2019/1/29 16:44
 * @Description:累加由map传递过来的计数
 */
public class WordCountReducer extends Reducer<Text,IntWritable,Text,IntWritable> {
    @Override
    protected void reduce(Text key, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException {
        int sum = 0;
        for(IntWritable val:values)
        {
            sum+=val.get();
        }
        context.write(key,new IntWritable(sum));
    }
}

5、关于shuffle过程，shuffle过程是由hadoop系统内部完成，shuffle是在map和reduce之间，对map的结果进行清洗、组合的过程。

借用hadoop权威指南里的一个图来类比说明

假设我们的数据样本是：

那么在map阶段形成的数据是：

hadoop 1
hadoop 1
abc 1
abc 1
test 1
test 1
wow 1
wow 1
wow 1
... ...

经过shuffle后大概是这样：

abc [1,1]
hadoop [1,1]
test [1,1]
wow [1,1,1]
... ...

shuffle对Map的结果进行排序并传输到Reduce进行处理 Map的结果并直接存放到硬盘,而是利用缓存做一些预排序处理 Map会调用Combiner，压缩，按key进行分区、排序等，尽量减少结果的大小 每个Map完成后都会通知Task，

然后Reduce就可以进行处理，shuffle其实就是性能关键点。shuffle的结果传递给reduce，reduce根据需求决定如何处理这些数据，本例中就是简单的求和。

6、程序入口，任务调度执行等

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
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;

public class WordCount {

    public static void main(String[] args) throws Exception {
        if(args.length!=2)
        {
            System.err.println("使用格式：WordCount <input path> <output path>");
            System.exit(-1);
        }
        //Configuration类代表作业的配置，该类会加载mapred-site.xml、hdfs-site.xml、core-site.xml等配置文件。
        Configuration conf =new Configuration();

        Path outPath = new Path(args[1]);
        //FileSystem里面包括很多系统，不局限于hdfs
        FileSystem fileSystem = outPath.getFileSystem(conf);
        //删除输出路径
        if(fileSystem.exists(outPath))
        {
            fileSystem.delete(outPath,true);
        }

        Job job = Job.getInstance(conf,"word count"); // new Job(conf, "word count");
        job.setJarByClass(WordCount.class);

        job.setMapperClass(WordCountMapper.class);
        //Combiner最终不能影响reduce输出的结果
//        job.setCombinerClass(WordCountReducer.class);
        job.setReducerClass(WordCountReducer.class);

        //一般情况下mapper和reducer的输出的数据类型是一样的，如果不一样，可以单独指定mapper的输出key、value的数据类型
        //job.setMapOutputKeyClass(Text.class);
        //job.setMapOutputValueClass(IntWritable.class);
        //输入类型通过InputFormat类来控制
        //hadoop默认的是TextInputFormat和TextOutputFormat,本例就是对文本进行处理所以可以不用配置。
        //job.setInputFormatClass(TextInputFormat.class);
        //job.setOutputFormatClass(TextOutputFormat.class);

        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(IntWritable.class);

        //指定的这个路径可以是单个文件、一个目录或符合特定文件模式的一系列文件。
        //从方法名称可以看出，可以通过多次调用这个方法来实现多路径的输入。
        FileInputFormat.addInputPath(job,new Path(args[0]));

　　　　 //在运行job前，这个目录不应该存在，如果存在hadoop会拒绝执行。这种预防措施的目的是防止数据丢失（长时间的job被意外覆盖）
        FileOutputFormat.setOutputPath(job,new Path(args[1]));

        System.exit(job.waitForCompletion(true) ? 0 : 1);
    }
}

7、放入hadoop平台中执行

1、打成wordcount.jar包
2、上传jar包到hadoop用户目录下
3、在hadoop用户目录下，用vi生成一个测试文档wc.input，里面随意填入一些词，用空格分隔词。本例中是：
[hadoop@hp4411s ~]$ cat wc.input
hadoop hadoop abc abc test test wow
wow wow
dnf dnf dnf dnf
wow
hd cd
ef hs
xudemin wow wow
xudemin dnf dnf
dnf mytest
4、将wc.input上传到hdfs文件系统中的/demo/input
   hadoop fs -mkdir -p /demo/input
   hadoop fs -put wc.input /demo/input
   hadoop fs -ls /demo/input

5、用hadoop执行jar包，输出结果到/demo/output,注意output目录不能存在，hadoop会自己建立这个目录，这是hadoop内部的一个机制，如果有这个目录，程序无法执行。
   hadoop jar wordcount.jar /demo/input /demo/output

6、查看运行结果，目录下有_SUCCESS文件，表示执行成功，结果在part-r-00000中
[hadoop@hp4411s ~]$ hadoop fs -ls /demo/output
Found 2 items
-rw-r--r--   1 hadoop supergroup          0 2019-01-30 03:42 /demo/output/_SUCCESS
-rw-r--r--   1 hadoop supergroup         73 2019-01-30 03:42 /demo/output/part-r-00000

7、查看part-r-00000
[hadoop@hp4411s ~]$ hadoop fs -cat /demo/output/part-r-00000
abc    2
cd    1
dnf    7
ef    1
hadoop    2
hd    1
hs    1
mytest    1
test    2
wow    6
xudemin    2

8、关于combiner，上述执行job的时候，程序注释了一段代码// job.setCombinerClass(WordCountReducer.class);

在Hadoop中，有一种处理过程叫Combiner，与Mapper和Reducer在处于同等地位，但其执行的时间介于Mapper和Reducer之间，其实就是Mapper和Reducer的中间处理过程，Mapper的输出是Combiner的输入，Combiner的输出是Reducer的输入。

combiner是什么作用？

因为hadoop的数据实际上是分布在各个不同的datanode，在mapper后，数据需要在从datanode上传输，如果数据很大很多，则会在网络上花费不少时间，而combiner可以先对数据进行处理，减少传输量。
处理的方式是自定义的，本例中，每次map运行之后，会对输出按照key进行排序，然后把输出传递给本地的combiner（按照作业的配置与Reducer一样），进行本地聚合。
combiner可以先对数据累加，实际上是执行了WordCountReducer类的内容，但是combine因为不是最后阶段，所以它只是帮组程序先累加了部分数据（本地的），并没有累加所有数据。
实际已经减少了mapper传递的kv数据量，最终到reducer阶段需要累加的数据已经减少了。

注意：combine是不会改变最终的reducer的结果，它是一个优化手段

用hadoop权威指南里天气数据的例子更深入解释：

例如获取历年的最高温度例子，以书中所说的1950年为例，在两个不同分区上的Mapper计算获得的结果分别如下：

第一个Mapper结果：(1950, [0, 10, 20])

第二个Mapper结果：(1950, [25, 15])

如果不考虑Combiner，按照正常思路，这两个Mapper的结果将直接输入到Reducer中处理，如下所示：

MaxTemperature：(1950, [0, 10, 20, 25, 15])

最终获取的结果是25。

如果考虑Combiner，按照正常思路，这两个Mapper的结果将分别输入到两个不同的Combiner中处理，获得的结果分别如下所示：

第一个Combiner结果：(1950, [20])

第二个Combiner结果：(1950, [25])

然后这两个Combiner的结果会输出到Reducer中处理，如下所示

MaxTemperature：(1950, [20, 25])

最终获取的结果是25。

由上可知：这两种方法的结果是一致的，使用Combiner最大的好处是节省网络传输的数据，这对于提高整体的效率是非常有帮助的。

但是，并非任何时候都可以使用Combiner处理机制，例如不是求历年的最高温度，而是求平均温度，则会有另一种结果。同样，过程如下，

如果不考虑Combiner，按照正常思路，这两个Mapper的结果将直接输入到Reducer中处理，如下所示：

AvgTemperature：(1950, [0, 10, 20, 25, 15])

最终获取的结果是14。

如果考虑Combiner，按照正常思路，这两个Mapper的结果将分别输入到两个不同的Combiner中处理，获得的结果分别如下所示：

第一个Combiner结果：(1950, [10])

第二个Combiner结果：(1950, [20])

然后这两个Combiner的结果会输出到Reducer中处理，如下所示

AvgTemperature：(1950, [10, 20])

最终获取的结果是15。

由上可知：这两种方法的结果是不一致的，所以在使用Combiner时，一定是优化的思路，但是不能影响到最终结果。