分布式计算模型MapReduce的学习

捡黄金的少年

已于 2022-06-16 19:55:16 修改

阅读量1k

点赞数

文章标签： mapreduce 学习 hadoop

于 2022-06-10 19:27:27 首次发布

本文链接：https://blog.csdn.net/weixin_43288858/article/details/125212215

版权

1、mapreduce的定义

MapReduce是一个分布式运算程序的编程框架，是用户开发“基于Hadoop的数据分析应用”的核心框架。
MapReduce核心功能是将用户编写的业务逻辑代码和自带默认组件整合成一个完整的分布式运算程序，并发运行在一个Hadoop集群上

2、MapReduce编程模型

MapReduce是采用一种分而治之的思想设计出来的分布式计算框架
那什么是分而治之呢？
- 比如一复杂、计算量大、耗时长的的任务，暂且称为“大任务”；
- 此时使用单台服务器无法计算或较短时间内计算出结果时，可将此大任务切分成一个个小的任务，小任务分别在不同的服务器上并行的执行；
- 最终再汇总每个小任务的结果
MapReduce由两个阶段组成：
- Map阶段（切分成一个个小的任务）
- Reduce阶段（汇总小任务的结果）

1. Map阶段

map阶段有一个关键的map()函数；
此函数的输入是键值对
输出是一系列键值对，输出写入本地磁盘。

2. Reduce阶段

reduce阶段有一个关键的函数reduce()函数
此函数的输入也是键值对（即map的输出（kv对））
输出也是一系列键值对，结果最终写入HDFS

3、Map&Reduce

4、mapreduce编程指导思想

mapReduce编程模型的总结：
MapReduce的开发一共有八个步骤其中map阶段分为2个步骤，shuffle阶段4个步骤，reduce阶段分为2个步骤

1. Map阶段2个步骤

第一步：设置inputFormat类，将数据切分成key，value对，输入到第二步
第二步：自定义map逻辑，处理我们第一步的输入kv对数据，然后转换成新的key，value对进行输出

2. shuffle阶段4个步骤

第三步：对上一步输出的key，value对进行分区。（相同key的kv对属于同一分区）
第四步：对每个分区的数据按照key进行排序
第五步：对分区中的数据进行规约(combine操作)，降低数据的网络拷贝（可选步骤）
第六步：对排序后的kv对数据进行分组；分组的过程中，key相同的kv对为一组；将同一组的kv对的所有value放到一个集合当中（每组数据调用一次reduce方法）

3. reduce阶段2个步骤

第七步：对多个map的任务进行合并，排序，写reduce函数自己的逻辑，对输入的key，value对进行处理，转换成新的key，value对进行输出
第八步：设置outputformat将输出的key，value对数据保存到文件中

hadoop当中常用的数据类型

hadoop没有沿用java当中基本的数据类型，而是自己进行封装了一套数据类型，其自己封装的类型与java的类型对应如下
下表常用的数据类型对应的Hadoop数据序列化类型

Java类型	Hadoop Writable类型
Boolean	BooleanWritable
Byte	ByteWritable
Int	IntWritable
Float	FloatWritable
Long	LongWritable
Double	DoubleWritable
String	Text
Map	MapWritable
Array	ArrayWritable
byte[]	BytesWritable

3、词频统计例子

1、map方法，构建map逻辑

1、继承hadoop的Mapper类 Mapper<LongWritable, Text, Text, IntWritable>，后面四个是Hadoop的序列化类型，因为要涉及到网络传输，输入的key为LongWritable，表示行数，value表示一行的记录String类型，Text, IntWritable表示输出的String类型的key，IntWritable表示输出的value为Int类型。

2、重新父类的setup和map方法，setup主要是初始化操作，map则自定义key和value的逻辑操作

(避免了重复造对象的操作)。

3、自定义Map层的操作，将一行数据进行解析，并把单词设为key，每个单词value设为1.方便后面的统计操作。

 @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        //value=hello,hello
        String[] words = value.toString().split(",");
        for (String word : words) {
            keyOut.set(word);
            intWritable.set(1);
            context.write(keyOut,intWritable);
        }
    }

package 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;

/**
 * @program: bigData01
 * @ClassName WordCount
 * @description:
 * @author:蒋皓洁
 * @create: 2022-06-08 10:07
 * @Version 1.0
 **/
public class WordCountMapper extends Mapper<LongWritable, Text, Text, IntWritable> {


    private Text keyOut;
    private IntWritable intWritable;

    /**
     * 初始化的方法
     *
     * @param context
     * @throws IOException
     * @throws InterruptedException
     */
    @Override
    protected void setup(Context context) throws IOException, InterruptedException {
        keyOut = new Text();
        intWritable = new IntWritable();
    }

    /**
     * 数据格式如下
     * hello,hello
     * world,world
     * hadoop,hadoop
     * 偏移量作为key，每一行的String作为Value
     * 读出则单词String类型作为key，数值作为value
     *
     * @param key
     * @param value
     * @param context
     * @throws IOException
     * @throws InterruptedException
     */
    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        //value=hello,hello
        String[] words = value.toString().split(",");
        for (String word : words) {
            keyOut.set(word);
            intWritable.set(1);
            context.write(keyOut,intWritable);
        }
    }
}

2、reduce(进而合并)

1、reduce阶段继承 extends Reducer<Text, IntWritable, Text, IntWritable>，前面两个序列化的key为map的输出key和value，后面两个为reduce的输出key和value

2、重新两个方法setup和reduce，因为在shuffle阶段对主动对数据进行了分区，对分区中的数据进行规约(combine操作)，降低数据的网络拷贝（可选步骤）（这个步骤词频统计没有重新方法，自定义逻辑，用的默认方法）

3、setup初始化化数据操作

4、reduce方法操作，reduce的参数(Text key, Iterable<IntWritable> values, Context contex),前面两个表示map的key，和相同key的value的集合如下，后面的Context contex表示数据输出，

这个reduce表示对value值的累加操作得到intWritable值，输出context.write(key, intWritable);


     * (hadoop,1)
     * (hadoop,1)
     * (hadoop,1)
     * (spark,1)
     * hadoop,Iterable<IntWritable>(1,1,1)

  protected void reduce(Text key, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException {

        /**
         * 所以对值进行累加操作
         */
        int sum = 0;
        for (IntWritable value : values
        ) {
            sum += value.get();
        }
        intWritable.set(sum);
        context.write(key, intWritable);
    }

package wordCount;

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

import java.io.IOException;

/**
 * @program: bigData01
 * @ClassName WordCountReduce
 * @description:
 * @author:蒋皓洁
 * @create: 2022-06-08 10:05
 * @Version 1.0
 **/
public class WordCountReduce extends Reducer<Text, IntWritable, Text, IntWritable> {


    private IntWritable intWritable;

    @Override
    protected void setup(Context context) throws IOException, InterruptedException {
        intWritable = new IntWritable();
    }

    /**
     * (hadoop,1)
     * (hadoop,1)
     * (hadoop,1)
     * (spark,1)
     * hadoop,Iterable<IntWritable>(1,1,1)
     *
     * @param key     单词
     * @param values  单词出现的次数组成的集合
     * @param context
     * @throws IOException
     * @throws InterruptedException
     */
    @Override
    protected void reduce(Text key, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException {

        /**
         * 所以对值进行累加操作
         */
        int sum = 0;
        for (IntWritable value : values
        ) {
            sum += value.get();
        }
        intWritable.set(sum);
        context.write(key, intWritable);
    }
}

3、main方法

和八个步骤基本一致

package wordCount;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.conf.Configured;
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.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;
import org.apache.hadoop.util.Tool;
import org.apache.hadoop.util.ToolRunner;


/**
 * @program: bigData01
 * @ClassName WordCountMapper
 * @description:
 * @author:蒋皓洁
 * @create: 2022-06-08 10:05
 * @Version 1.0
 **/
public class WordCount extends Configured implements Tool {


    @Override
    public int run(String[] args) throws Exception {
        Configuration configuration = super.getConf();


        //job对象
        Job job = Job.getInstance(configuration, WordCount.class.getName());
        //需要将程序提交到集群操作，需要setJarByClass
        job.setJarByClass(WordCount.class);
        //第一步:设置InputFormat，读取分片内容，生成key，v
        job.setInputFormatClass(TextInputFormat.class);
        TextInputFormat.addInputPath(job, new Path(args[0]));// new Path(args[0])可写死，可传参
        //第二步：map逻辑，读取key，value生成k2 v2
        job.setMapperClass(WordCountMapper.class);
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(IntWritable.class);
        //第三，四，五，六分别是分区，排序，规约，分组
        //第七步:reduce逻辑
        job.setReducerClass(WordCountReduce.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(IntWritable.class);

        //第八步设置outPutFormat
        job.setOutputFormatClass(TextOutputFormat.class);
        //设置输出路径
        TextOutputFormat.setOutputPath(job, new Path(args[1]));

        boolean b = job.waitForCompletion(true);
        return b ? 0 : 1;
    }

    public static void main(String[] args) throws Exception {
        Configuration entries = new Configuration();
        int run = ToolRunner.run(entries, new WordCount(), args);//传入三个参数
        System.exit(run);
    }
}

4、join例子

订单数据表t_order：

id	date	pid	amount
1001	20150710	P0001	2
1002	20150710	P0002	3
1002	20150710	P0003	3

商品信息表t_product

id	pname	category_id	price
P0001	小米5	1000	2000
P0002	锤子T1	1000	3000

如果写SQL就是如下操作

select  a.id,a.date,b.name,b.category_id,b.price 
from t_order a 
join t_product  b
 on a.pid = b.id

1、map

map逻辑如下，查询到的，将商品表的ID作为key，方便后面计算

package joinCount;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.lib.input.FileSplit;

import java.io.IOException;
/**
 * @program: bigData01
 * @ClassName ReduceJoinMapper
 * @description:
 * @author:蒋皓洁
 * @create: 2022-06-09 15:27
 * @Version 1.0
 **/
public class ReduceJoinMapper  extends Mapper<LongWritable, Text, Text, Text> {

    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        //现在我们读取了两个文件，如何确定当前处理的这一行数据是来自哪一个文件里面的
        //方式一：通过获取文件的切片，获得文件明
        /*
        FileSplit inputSplit = (FileSplit) context.getInputSplit();//获取我们输入的文件的切片
        //获取文件名称
        String name = inputSplit.getPath().getName();
        if (name.equals("orders.txt")) {
            //订单表数据
        } else {
            //商品表数据
        }
        */

        String[] split = value.toString().split(",");

        //方式二：因为t_product表，都是以p开头，所以可以作为判断的依据
        if (value.toString().startsWith("p")) {
            //p0002,锤子T1,1000,3000
            //以商品id作为key2,相同商品的数据都会到一起去
            context.write(new Text(split[0]), value);
        } else {
            //order
            // 1001,20150710,p0001,2
            context.write(new Text(split[2]), value);
        }
    }

}

2、reduce

对如果不是p开头的数据，则是订单数据，否则是商品基础信息数据

对数据进行筛选进而合并

package joinCount;

/**
 * @program: bigData01
 * @ClassName ReduceJoinReducer
 * @description:
 * @author:蒋皓洁
 * @create: 2022-06-09 15:47
 * @Version 1.0
 **/
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

import java.io.IOException;
import java.util.ArrayList;

public class ReduceJoinReducer extends Reducer<Text, Text, Text, NullWritable> {
    @Override
    protected void reduce(Text key, Iterable<Text> values, Context context) throws IOException, InterruptedException {
        //p0003 商品，订单的数据多条；保存订单信息
        ArrayList<String> orders = new ArrayList<>();
        //保存商品信息
        String product = "";

        for (Text value : values) {
            if (value.toString().startsWith("p")) {//商品
                product = value.toString();
            } else {
                orders.add(value.toString());
            }
        }

        for (String order : orders) {
            context.write(new Text(order + "\t" + product), NullWritable.get());
        }
    }
}

3、main方法

main方法无多大区别

package joinCount;

/**
 * @program: bigData01
 * @ClassName ReduceJoinMain
 * @description:
 * @author:蒋皓洁
 * @create: 2022-06-09 15:57
 * @Version 1.0
 **/
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.conf.Configured;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;
import org.apache.hadoop.util.Tool;
import org.apache.hadoop.util.ToolRunner;

public class ReduceJoinMain extends Configured implements Tool {
    @Override
    public int run(String[] args) throws Exception {
        //获取job对象
        Job job = Job.getInstance(super.getConf(), ReduceJoinMain.class.getSimpleName());
        job.setJarByClass(ReduceJoinMain.class);

        //第一步：读取文件
        job.setInputFormatClass(TextInputFormat.class);
        TextInputFormat.addInputPath(job, new Path(args[0]));

        //第二步：设置自定义mapper逻辑
        job.setMapperClass(ReduceJoinMapper.class);
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(Text.class);

        //分区，排序，规约，分组 省略

        //第七步：设置reduce逻辑
        job.setReducerClass(ReduceJoinReducer.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(NullWritable.class);

        //第八步：设置输出数据路径
        job.setOutputFormatClass(TextOutputFormat.class);
        TextOutputFormat.setOutputPath(job, new Path(args[1]));

        boolean b = job.waitForCompletion(true);
        return b ? 0 : 1;
    }

    public static void main(String[] args) throws Exception {
        int run = ToolRunner.run(new Configuration(), new ReduceJoinMain(), args);
        System.exit(run);
    }
}

5、map join

1、原理阐述

适用于关联表中有小表的情形；
可以将小表分发到所有的map节点，这样，map节点就可以在本地对自己所读到的大表数据进行join并输出最终结果，可以大大提高join操作的并发度，加快处理速度

2、实现示例

先在mapper类中预先定义好小表，进行join
引入实际场景中的解决方案：一次加载数据库或者用
定义mapper类：

因为订单表和商品是多对一的关系，所以我们可以先把商品表的数据预加载到map中处理

map如下

package joinMapCount;

/**
 * @program: bigData01
 * @ClassName MapJoinMapper
 * @description:
 * @author:蒋皓洁
 * @create: 2022-06-09 16:23
 * @Version 1.0
 **/
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FSDataInputStream;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URI;
import java.util.HashMap;
import java.util.Map;

public class MapJoinMapper extends Mapper<LongWritable, Text, Text, NullWritable> {
    //用于保存商品表的数据；productMap中的key是商品id，value是与key对应的表记录
    private Map<String, String> productMap;

    /**
     * 初始化方法，只在程序启动调用一次
     *
     * @param context
     * @throws IOException
     * @throws InterruptedException
     */
    @Override
    protected void setup(Context context) throws IOException, InterruptedException {

        productMap = new HashMap<String, String>();

        Configuration configuration = context.getConfiguration();

        //获取到所有的缓存文件
        //方式一
        URI[] cacheFiles = Job.getInstance(context.getConfiguration()).getCacheFiles();
        //方式二：deprecated
        //URI[] cacheFiles = DistributedCache.getCacheFiles(configuration);

        //现在只有一个缓存文件放进了分布式缓存中
        URI cacheFile = cacheFiles[0];

        //获取FileSystem
        FileSystem fileSystem = FileSystem.get(cacheFile, configuration);
        //读取文件，获取到输入流。这里面装的都是商品表的数据
        FSDataInputStream fsDataInputStream = fileSystem.open(new Path(cacheFile));

        /**
         * 商品表数据如下：
         * p0001,xiaomi,1000,2
         * p0002,appale,1000,3
         * p0003,samsung,1000,4
         */
        //获取到BufferedReader之后，可以一行一行的读取数据
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(fsDataInputStream));
        String line = null;
        //每次循环，获得表的一行数据
        while ((line = bufferedReader.readLine()) != null) {
            String[] split = line.split(",");
            productMap.put(split[0], line);
        }
    }

    /**
     * @param key
     * @param value   订单表的记录，如1001,20150710,p0001,2
     * @param context
     * @throws IOException
     * @throws InterruptedException
     */
    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        String[] split = value.toString().split(",");
        //获取订单表的商品id
        String pid = split[2];

        //获取商品表的数据
        String pdtsLine = productMap.get(pid);

        context.write(new Text(value.toString() + "\t" + pdtsLine), NullWritable.get());
    }
}

main方法如下

package joinMapCount;

/**
 * @program: bigData01
 * @ClassName MapJoinMain
 * @description:
 * @author:蒋皓洁
 * @create: 2022-06-09 16:24
 * @Version 1.0
 **/
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.conf.Configured;
import org.apache.hadoop.filecache.DistributedCache;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;


import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;
import org.apache.hadoop.util.Tool;
import org.apache.hadoop.util.ToolRunner;

import java.net.URI;

/**
 * 需求：同reduce join
 * 实现：select a.id, a.date, b.name, b.category_id, b.price
 * from t_order a
 * join t_product b
 * on a.pid = b.id
 */
public class MapJoinMain extends Configured implements Tool {
    @Override
    public int run(String[] args) throws Exception {
        //分布式缓存的hdfs路径
        URI uri = new URI("file:///D:/hadoop/mapjoin/cache/pdts.txt");
//
        //本地路径：需要用一下形式file:///C:/1、HK/.../pdts.txt   ；需要指定到具体的文件；如果是使用file:///c:\\1、HK\\3、ME...不符合语法会报错
        //URI uri = new URI("file:///C:/1、HK/3、ME/2、高级0x/1、Hadoop集群升级课件/9、MapReduce/MR第一次/12、join操作/map端join/cache/pdts.txt");
        Configuration configuration = super.getConf();
        //添加缓存文件 方式二：deprecated
        DistributedCache.addCacheFile(uri, configuration);

        //获取job对象
        Job job = Job.getInstance(configuration, MapJoinMain.class.getSimpleName());
        //添加缓存文件：方式一
//        job.addCacheFile(uri);
        job.setJarByClass(MapJoinMain.class);

        //读取文件，解析成为key，value对
        job.setInputFormatClass(TextInputFormat.class);
        TextInputFormat.addInputPath(job, new Path(args[0]));

        job.setMapperClass(MapJoinMapper.class);
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(NullWritable.class);

        //没有reducer逻辑，不用设置了
        job.setOutputFormatClass(TextOutputFormat.class);
        TextOutputFormat.setOutputPath(job, new Path(args[1]));

        job.setNumReduceTasks(2);

        boolean b = job.waitForCompletion(true);
        return b ? 0 : 1;
    }

    public static void main(String[] args) throws Exception {
        int run = ToolRunner.run(new Configuration(), new MapJoinMain(), args);
        System.exit(run);
    }
}

6、自定义FileOutputFormat文件流输出

package goodOrBad;

import org.apache.hadoop.fs.FSDataOutputStream;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.RecordWriter;
import org.apache.hadoop.mapreduce.TaskAttemptContext;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

import java.io.IOException;

//泛型指的是输出的k，v类型
public class MyOutputFormat extends FileOutputFormat<Text, NullWritable> {

    @Override
    public RecordWriter<Text, NullWritable> getRecordWriter(TaskAttemptContext context) throws IOException, InterruptedException {
        FileSystem fs = FileSystem.get(context.getConfiguration());
        Path goodComment = new Path("file:///D:\\hadoop\\5、自定义outputFormat\\测试传感器数据\\input\\good\\1.txt");
        Path badComment = new Path("file:///D:\\hadoop\\5、自定义outputFormat\\测试传感器数据\\input\\bad\\1.txt");
        FSDataOutputStream goodOutputStream = fs.create(goodComment);
        FSDataOutputStream badOutputStream = fs.create(badComment);
        return new MyRecordWriter(goodOutputStream, badOutputStream);
    }

    static class MyRecordWriter extends RecordWriter<Text, NullWritable> {
        FSDataOutputStream goodStream = null;
        FSDataOutputStream badStream = null;

        public MyRecordWriter(FSDataOutputStream goodStream, FSDataOutputStream badStream) {
            this.goodStream = goodStream;
            this.badStream = badStream;
        }

        @Override
        public void write(Text key, NullWritable value) throws IOException, InterruptedException {
            if (key.toString().split(",")[1].equals("\"氧气传感器\"")) {//好评
                goodStream.write(key.toString().getBytes());
                goodStream.write("\r\n".getBytes());
            } else {//中评或差评
                badStream.write(key.toString().getBytes());
                badStream.write("\r\n".getBytes());
            }
        }

        //释放资源
        @Override
        public void close(TaskAttemptContext context) throws IOException, InterruptedException {
            if (badStream != null) {
                badStream.close();
            }
            if (goodStream != null) {
                goodStream.close();
            }
        }
    }
}

main方法如下：

package goodOrBad;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.conf.Configured;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.lib.input.TextInputFormat;
import org.apache.hadoop.util.Tool;
import org.apache.hadoop.util.ToolRunner;

import java.io.IOException;

public class MyOwnOutputFormatMain extends Configured implements Tool {
    @Override
    public int run(String[] args) throws Exception {
        Configuration conf = super.getConf();
        Job job = Job.getInstance(conf, MyOwnOutputFormatMain.class.getSimpleName());
        job.setJarByClass(MyOwnOutputFormatMain.class);

        job.setInputFormatClass(TextInputFormat.class);
        TextInputFormat.addInputPath(job, new Path(args[0]));

        job.setMapperClass(MyOwnMapper.class);
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(NullWritable.class);

        //使用默认的Reduce类的逻辑
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(NullWritable.class);

        job.setOutputFormatClass(MyOutputFormat.class);
        //设置一个输出目录，这个目录会输出一个success的成功标志的文件
        MyOutputFormat.setOutputPath(job, new Path(args[1]));

        //可以观察现象
        job.setNumReduceTasks(2);

        boolean b = job.waitForCompletion(true);
        return b ? 0 : 1;
    }

    //kout：评分等级 0， 1， 2
    public static class MyOwnMapper extends Mapper<LongWritable, Text, Text, NullWritable> {
        @Override
        protected void map(LongWritable key, Text value, Mapper.Context context) throws IOException, InterruptedException {
            //评分
            //String commentStatus = split[9];
            context.write(value, NullWritable.get());
        }
    }

    public static void main(String[] args) throws Exception {
        Configuration configuration = new Configuration();
        ToolRunner.run(configuration, new MyOwnOutputFormatMain(), args);
    }
}

路径参数args，在idea中的配置如下，参数以逗号隔开

放在liunx集群运行，参数之间也用空格隔开

hadoop jar mr01-1.0-SNAPSHOT.jar wordCount.WordCount /wordcount /wc010152

7、mapreduce的partitioner详解

在mapreduce执行当中，有一个默认的步骤就是partition分区；
- 分区主要的作用就是默认将key相同的kv对数据发送到同一个分区中；
- 在mapreduce当中有一个抽象类叫做Partitioner，默认使用的实现类是HashPartitioner，我们可以通过HashPartitioner的源码，查看到分区的逻辑如下
我们MR编程的第三步就是分区；这一步中决定了map生成的每个kv对，被分配到哪个分区里
- 那么这是如何做到的呢？
- 要实现此功能，涉及到了分区器的概念；

默认分区器HashPartitioner

MR框架有个默认的分区器HashPartitioner

我们能观察到：
- HashPartitioner实现了Partitioner接口
- 它实现了getPartition()方法
  - 此方法中对k取hash值
  - 再与MAX_VALUE按位与
  - 结果再模上reduce任务的个数
- 所以，能得出结论，相同的key会落入同一个分区中

自定义分区器

实际生产中，有时需要自定义分区的逻辑，让key落入我们想让它落入的分区
此时就需要自定义分区器
如何实现？
参考默认分区器HashPartitioner
- 自定义的分区器类，如CustomPartitioner
  - 实现接口Partitioner
  - 实现getPartition方法；此方法中定义分区的逻辑
- main方法
  - 将自定义的分区器逻辑添加进来job.setPartitionerClass(CustomPartitioner.class)
  - 设置对应的reduce任务个数job.setNumReduceTasks(3)

现有一份关于手机的流量数据，样本数据如下

格式说明

==需求==：使用mr，实现将不同的手机号的数据划分到6个不同的文件里面去，具体划分规则如下

135开头的手机号分到一个文件里面去，
136开头的手机号分到一个文件里面去，
137开头的手机号分到一个文件里面去，
138开头的手机号分到一个文件里面去，
139开头的手机号分到一个文件里面去，
其他开头的手机号分到一个文件里面去

根据mr编程8步，需要实现的代码有：

一、针对输入数据，设计JavaBean
二、自定义的Mapper逻辑（第二步）
三、自定义的分区类（第三步）
四、自定义的Reducer逻辑（第七步）
五、main程序入口

1、创建javaBean

实现Writable接口，重新接口的write和readFields方法，实现序列化和反序列化

package partitioner;

import org.apache.hadoop.io.Writable;

import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;

/**
 * 实现Writable接口，重新接口的write和readFields方法，实现序列化和反序列化
 */
public class FlowBean implements Writable /*实现可序列化、反序列化*/ {
    private Integer upFlow;
    private Integer downFlow;
    private Integer upCountFlow;
    private Integer downCountFlow;

    /**
     * 序列化方法
     *
     * @param out
     * @throws IOException
     */
    @Override
    public void write(DataOutput out) throws IOException {
        out.writeInt(upFlow);
        out.writeInt(downFlow);
        out.writeInt(upCountFlow);
        out.writeInt(downCountFlow);
    }


    /**
     * 反序列化方法
     * 反序列化需要注意：使用正确的反序列化的方法；反序列化的顺序跟序列化的顺序保持一致
     *
     * @param in
     * @throws IOException
     */

    @Override
    public void readFields(DataInput in) throws IOException {
        this.upFlow = in.readInt();
        this.downFlow = in.readInt();
        this.upCountFlow = in.readInt();
        this.downCountFlow = in.readInt();
    }

    public Integer getUpFlow() {
        return upFlow;
    }

    public void setUpFlow(Integer upFlow) {
        this.upFlow = upFlow;
    }

    public Integer getDownFlow() {
        return downFlow;
    }

    public void setDownFlow(Integer downFlow) {
        this.downFlow = downFlow;
    }

    public Integer getUpCountFlow() {
        return upCountFlow;
    }

    public void setUpCountFlow(Integer upCountFlow) {
        this.upCountFlow = upCountFlow;
    }

    public Integer getDownCountFlow() {
        return downCountFlow;
    }

    public void setDownCountFlow(Integer downCountFlow) {
        this.downCountFlow = downCountFlow;
    }

    @Override
    public String toString() {
        return "FlowBean{" +
                "upFlow=" + upFlow +
                ", downFlow=" + downFlow +
                ", upCountFlow=" + upCountFlow +
                ", downCountFlow=" + downCountFlow +
                '}';
    }
}

2、自定义map类

将手机号作为key，对象作为value，setup方法是初始化方法

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

import java.io.IOException;

public class FlowMapper extends Mapper<LongWritable, Text, Text, FlowBean> {
    private FlowBean flowBean;
    private Text text;

    @Override
    protected void setup(Context context) throws IOException, InterruptedException {
        flowBean = new FlowBean();
        text = new Text();
    }

    /**
     * 1363157985066	13726230503	00-FD-07-A4-72-B8:CMCC
     * 120.196.100.82	i02.c.aliimg.com	游戏娱乐	24	27	2481	24681	200
     *
     * @param key
     * @param value
     * @param context
     * @throws IOException
     * @throws InterruptedException
     */
    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        String[] fields = value.toString().split("\t");

        String phoneNum = fields[1];
        String upFlow = fields[6];
        String downFlow = fields[7];
        String upCountFlow = fields[8];
        String downCountFlow = fields[9];

        text.set(phoneNum);

        flowBean.setUpFlow(Integer.parseInt(upFlow));
        flowBean.setDownFlow(Integer.parseInt(downFlow));
        flowBean.setUpCountFlow(Integer.parseInt(upCountFlow));
        flowBean.setDownCountFlow(Integer.parseInt(downCountFlow));

        context.write(text, flowBean);

    }
}

3、继承Partitioner实现分区

package partitioner;

import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Partitioner;

/**
 * 继承Partitioner接口，实现分区
 */
public class PartitionOwn extends Partitioner<Text, FlowBean> {
    @Override
    public int getPartition(Text text, FlowBean flowBean, int numPartitions) {
        String phoenNum = text.toString();

        if(null != phoenNum && !phoenNum.equals("")){
            if(phoenNum.startsWith("135")){
                return 0;
            }else if(phoenNum.startsWith("136")){
                return 1;
            }else if(phoenNum.startsWith("137")){
                return 2;
            }else if(phoenNum.startsWith("138")){
                return 3;
            }else if(phoenNum.startsWith("139")){
                return 4;
            }else {
                return 5;
            }
        }else{
            return 5;
        }
    }
}

4、自定义Reducer

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

import java.io.IOException;

public class FlowReducer extends Reducer<Text, FlowBean, Text, Text> {

    /**
     * 同一个手机号的数据，调用一次reduce方法
     * @param key
     * @param values
     * @param context
     * @throws IOException
     * @throws InterruptedException
     */
    @Override
    protected void reduce(Text key, Iterable<FlowBean> values, Context context) throws IOException, InterruptedException {
        int upFlow = 0;
        int donwFlow = 0;
        int upCountFlow = 0;
        int downCountFlow = 0;

        for (FlowBean value : values) {
            upFlow += value.getUpFlow();
            donwFlow += value.getDownFlow();
            upCountFlow += value.getUpCountFlow();
            downCountFlow += value.getDownCountFlow();
        }
        context.write(key, new Text(upFlow + "\t" + donwFlow + "\t" + upCountFlow + "\t" + downCountFlow));
    }
}

5、main方法

package partitioner;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.conf.Configured;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;

import org.apache.hadoop.util.Tool;
import org.apache.hadoop.util.ToolRunner;

public class FlowMain extends Configured implements Tool {
    @Override
    public int run(String[] args) throws Exception {
        //获取job对象
        Job job = Job.getInstance(super.getConf(), "flowCount");
        //如果程序打包运行必须要设置这一句
        job.setJarByClass(FlowMain.class);

        job.setInputFormatClass(TextInputFormat.class);
        TextInputFormat.addInputPath(job, new Path(args[0]));

        job.setMapperClass(FlowMapper.class);
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(FlowBean.class);

        //自定义分区器：
        job.setPartitionerClass(PartitionOwn.class);
        //设置reduce个数
        job.setNumReduceTasks(Integer.parseInt(args[2]));

        job.setReducerClass(FlowReducer.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(Text.class);

        job.setOutputFormatClass(TextOutputFormat.class);
        TextOutputFormat.setOutputPath(job, new Path(args[1]));

        boolean b = job.waitForCompletion(true);
        return b ? 0 : 1;
    }


    public static void main(String[] args) throws Exception {
        Configuration configuration = new Configuration();
        //configuration.set("mapreduce.framework.name", "local");
        //configuration.set("yarn.resourcemanager.hostname", "local");

        int run = ToolRunner.run(configuration, new FlowMain(), args);
        System.exit(run);
    }

}

注意：对于我们自定义分区的案例，==必须打成jar包上传到集群==上面去运行，因为我们本地已经没法通过多线程模拟本地程序运行了，将我们的数据上传到hdfs上面去，然后通过 hadoop jar提交到集群上面去运行，观察我们分区的个数与reduceTask个数的关系

8、mapreduce当中的排序

. 可排序的Key

排序是MapReduce框架中最重要的操作之一。
- MapTask和ReduceTask均会对数据按照key进行排序。该操作属于Hadoop的默认行为。任何应用程序中的数据均会被排序，而不管逻辑上是否需要。
- 默认排序是按照字典顺序排序，且实现该排序的方法是快速排序。
对于MapTask，它会将处理的结果暂时放到环形缓冲区中，当环形缓冲区使用率达到一定阈值后，再对缓冲区中的数据进行一次快速排序，并将这些有序数据溢写到磁盘上，而当数据处理完毕后，它会对磁盘上所有文件进行归并排序。
对于ReduceTask，它从每个执行完成的MapTask上远程拷贝相应的数据文件
- 如果文件大小超过一定阈值，则溢写磁盘上，否则存储在内存中。
- 如果磁盘上文件数目达到一定阈值，则进行一次归并排序以生成一个更大文件；
- 如果内存中文件大小或者数目超过一定阈值，则进行一次合并后将数据溢写到磁盘上。
- 当所有数据拷贝完毕后，ReduceTask统一对内存和磁盘上的所有数据进行一次归并排序。

2. 排序的种类：

1、部分排序

MapReduce根据输入记录的键对数据集排序。保证输出的每个文件内部有序
2、全排序

最终输出结果只有一个文件，且文件内部有序。实现方式是只设置一个ReduceTask。但该方法在处理大型文件时效率极低，因为一台机器处理所有文件，完全丧失了MapReduce所提供的并行架构
3、辅助排序

在Reduce端对key进行分组。应用于：在接收的key为bean对象时，想让一个或几个字段相同（全部字段比较不相同）的key进入到同一个reduce方法时，可以采用==分组排序==。
4、二次排序
- 二次排序：mr编程中，需要先按输入数据的某一列a排序，如果相同，再按另外一列b排序；
- mr自带的类型作为key无法满足需求，往往需要自定义JavaBean作为map输出的key
- JavaBean中，使用compareTo方法指定排序规则。

3. 二次排序

数据：样本数据如下；

每条数据有5个字段，分别是手机号、上行包总个数、下行包总个数、上行总流量、下行总流量
==需求==先对下行包总个数升序排序；若相等，再按上行总流量进行降序排序
根据mr编程8步，需要实现的代码有：
- 一、针对输入数据及二次排序规则，设计JavaBean
- 二、自定义的Mapper逻辑（第二步）
- 三、自定义的Reducer逻辑（第七步）
- 四、main程序入口
代码实现：
一、定义javaBean对象，用于封装数据及定义排序规则

import org.apache.hadoop.io.WritableComparable;

import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;

//bean要能够可序列化且可比较，所以需要实现接口WritableComparable
public class FlowSortBean implements WritableComparable<FlowSortBean> {
    private String phone;
    //上行包个数
    private Integer upPackNum;
    //下行包个数
    private Integer downPackNum;
    //上行总流量
    private Integer upPayload;
    //下行总流量
    private Integer downPayload;

    //用于比较两个FlowSortBean对象

    /**
     * 先对下行包总个数升序排序；若相等，再按上行总流量进行降序排序
     * @param o
     * @return
     */
    @Override
    public int compareTo(FlowSortBean o) {
        //升序
        int i = this.downPackNum.compareTo(o.downPackNum);
        if (i == 0) {
            //降序
            i = -this.upPayload.compareTo(o.upPayload);
        }
        return i;
    }

    //序列化
    @Override
    public void write(DataOutput out) throws IOException {
        out.writeUTF(phone);
        out.writeInt(upPackNum);
        out.writeInt(downPackNum);
        out.writeInt(upPayload);
        out.writeInt(downPayload);
    }

    //反序列化
    @Override
    public void readFields(DataInput in) throws IOException {
        this.phone = in.readUTF();
        this.upPackNum = in.readInt();
        this.downPackNum = in.readInt();
        this.upPayload = in.readInt();
        this.downPayload = in.readInt();
    }

    @Override
    public String toString() {
        return phone + "\t" + upPackNum + "\t" + downPackNum + "\t" + upPayload + "\t" + downPayload;
    }

    //setter、getter方法
    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    public Integer getUpPackNum() {
        return upPackNum;
    }

    public void setUpPackNum(Integer upPackNum) {
        this.upPackNum = upPackNum;
    }

    public Integer getDownPackNum() {
        return downPackNum;
    }

    public void setDownPackNum(Integer downPackNum) {
        this.downPackNum = downPackNum;
    }

    public Integer getUpPayload() {
        return upPayload;
    }

    public void setUpPayload(Integer upPayload) {
        this.upPayload = upPayload;
    }

    public Integer getDownPayload() {
        return downPayload;
    }

    public void setDownPayload(Integer downPayload) {
        this.downPayload = downPayload;
    }
}

二、自定义mapper类

import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

import java.io.IOException;

public class FlowSortMapper extends Mapper<LongWritable, Text, FlowSortBean, NullWritable> {

    private FlowSortBean flowSortBean;

    //初始化
    @Override
    protected void setup(Context context) throws IOException, InterruptedException {
        flowSortBean = new FlowSortBean();
    }

    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        /**
         * 手机号	上行包	下行包	上行总流量	下行总流量
         * 13480253104	3	3	180	180
         */
        String[] fields = value.toString().split("\t");

        flowSortBean.setPhone(fields[0]);
        flowSortBean.setUpPackNum(Integer.parseInt(fields[1]));
        flowSortBean.setDownPackNum(Integer.parseInt(fields[2]));
        flowSortBean.setUpPayload(Integer.parseInt(fields[3]));
        flowSortBean.setDownPayload(Integer.parseInt(fields[4]));

        context.write(flowSortBean, NullWritable.get());
    }
}

三、自定义reducer类

import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.mapreduce.Reducer;

import java.io.IOException;

public class FlowSortReducer extends Reducer<FlowSortBean, NullWritable, FlowSortBean, NullWritable> {

    @Override
    protected void reduce(FlowSortBean key, Iterable<NullWritable> values, Context context) throws IOException, InterruptedException {
        //经过排序后的数据，直接输出即可
        context.write(key, NullWritable.get());
    }

四、main程序入口

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.conf.Configured;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;
import org.apache.hadoop.util.Tool;
import org.apache.hadoop.util.ToolRunner;

public class FlowSortMain extends Configured implements Tool {
    @Override
    public int run(String[] args) throws Exception {
        //获取job对象
        Job job = Job.getInstance(super.getConf(), "flowSort");
        //如果程序打包运行必须要设置这一句
        job.setJarByClass(FlowSortMain.class);

        job.setInputFormatClass(TextInputFormat.class);
        TextInputFormat.addInputPath(job, new Path(args[0]));

        job.setMapperClass(FlowSortMapper.class);
        job.setMapOutputKeyClass(FlowSortBean.class);
        job.setMapOutputValueClass(NullWritable.class);

        job.setReducerClass(FlowSortReducer.class);
        job.setOutputKeyClass(FlowSortBean.class);
        job.setOutputValueClass(NullWritable.class);

        job.setOutputFormatClass(TextOutputFormat.class);
        TextOutputFormat.setOutputPath(job, new Path(args[1]));

        boolean b = job.waitForCompletion(true);

        return b ? 0 : 1;
    }


    public static void main(String[] args) throws Exception {
        Configuration configuration = new Configuration();
        int run = ToolRunner.run(configuration, new FlowSortMain(), args);
        System.exit(run);
    }

}

9、mapreduce中的combiner

减少传输数据量，本地先combiner组合一下

1. combiner基本介绍

combiner类本质也是reduce聚合，combiner类继承Reducer父类
combine是运行在map端的，对map task的结果做聚合；而reduce是将来自不同的map task的数据做聚合
作用：
- combine可以减少map task落盘及向reduce task传输的数据量
是否可以做map端combine：
- 并非所有的mapreduce job都适用combine，无论适不适用combine，都不能对最终的结果造成影响；比如下边求平均值的例子，就不适用适用combine
```
Mapper 3 5 7 ->(3+5+7)/3=5 2 6 ->(2+6)/2=4 
 Reducer (3+5+7+2+6)/5=23/5   不等于   (5+4)/2=9/2
```

2. 需求：

对于我们前面的wordCount单词计数统计，我们加上Combiner过程，实现map端的数据进行汇总之后，再发送到reduce端，减少数据的网络拷贝
自定义combiner类

其实直接使用词频统计中的reducer类作为combine类即可
在main方法中加入

 job.setCombinerClass(MyReducer.class);

运行程序，观察控制台有combiner和没有combiner的异同
10、mapreduce中的GroupingComparator分组详解
关键类GroupingComparator
是mapreduce当中reduce端决定哪些数据作为一组，调用一次reduce的逻辑
默认是key相同的kv对，作为同一组；每组调用一次reduce方法；
可以自定义GroupingComparator，实现自定义的分组逻辑

1、自定义WritableComparator类

（1）继承WritableComparator
（2）重写compare()方法

@Override
public int compare(WritableComparable a, WritableComparable b) {
        // 比较的业务逻辑
        return result;
}

（3）创建一个构造将比较对象的类传给父类

protected OrderGroupingComparator() {
        super(OrderBean.class, true);
}

2. 需求：

现在有订单数据如下

订单id	商品id	成交金额
Order_0000001	Pdt_01	222.8
Order_0000001	Pdt_05	25.8
Order_0000002	Pdt_03	522.8
Order_0000002	Pdt_04	122.4
Order_0000002	Pdt_05	722.4
Order_0000003	Pdt_01	222.8

现在需要求取每个订单当中金额最大的商品
根据mr编程8步，需要实现的代码有：
- 一、针对输入数据及相同订单按金额降序排序，设计JavaBean
- 二、自定义的Mapper逻辑（第二步）
- 三、自定义分区器，相同订单分到同一区（第三步）
- 四、自定义分区内排序（在JavaBean中已完成）（第四步）
- 五、自定义分组，相同订单的为同一组（第六步）
- 六、自定义的Reducer逻辑（第七步）
- 七、main程序入口

1、JavaBean如下

import org.apache.hadoop.io.WritableComparable;

import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;

public class OrderBean implements WritableComparable<OrderBean> {
    private String orderId;
    private Double price;

    /**
     * key间的比较规则
     *
     * @param o
     * @return
     */
    @Override
    public int compareTo(OrderBean o) {
        //注意：如果是不同的订单之间，金额不需要排序，没有可比性
        int orderIdCompare = this.orderId.compareTo(o.orderId);
        if (orderIdCompare == 0) {
            //比较金额，按照金额进行倒序排序
            int priceCompare = this.price.compareTo(o.price);
            return -priceCompare;
        } else {
            //如果订单号不同，没有可比性，直接返回订单号的升序排序即可
            return orderIdCompare;
        }
    }

    /**
     * 序列化方法
     *
     * @param out
     * @throws IOException
     */
    @Override
    public void write(DataOutput out) throws IOException {
        out.writeUTF(orderId);
        out.writeDouble(price);
    }

    /**
     * 反序列化方法
     *
     * @param in
     * @throws IOException
     */
    @Override
    public void readFields(DataInput in) throws IOException {
        this.orderId = in.readUTF();
        this.price = in.readDouble();
    }

    public String getOrderId() {
        return orderId;
    }

    public void setOrderId(String orderId) {
        this.orderId = orderId;
    }

    public Double getPrice() {
        return price;
    }

    public void setPrice(Double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return orderId + "\t" + price;
    }
}

2、自定义mapper类：

mport org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

import java.io.IOException;

public class GroupMapper extends Mapper<LongWritable, Text, OrderBean, NullWritable> {

    /**
     * Order_0000001	Pdt_01	222.8
     * Order_0000001	Pdt_05	25.8
     * Order_0000002	Pdt_03	322.8
     * Order_0000002	Pdt_04	522.4
     * Order_0000002	Pdt_05	822.4
     * Order_0000003	Pdt_01	222.8
     * Order_0000003	Pdt_03	322.8
     * Order_0000003	Pdt_04	522.4
     *
     * @param key
     * @param value
     * @param context
     * @throws IOException
     * @throws InterruptedException
     */
    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        String[] fields = value.toString().split("\t");
        //Order_0000003	Pdt_04	522.4
        OrderBean orderBean = new OrderBean();
        orderBean.setOrderId(fields[0]);
        orderBean.setPrice(Double.valueOf(fields[2]));

        //输出orderBean
        context.write(orderBean, NullWritable.get());
    }
}

3、自定义分区类：

import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.mapreduce.Partitioner;

public class GroupPartitioner extends Partitioner<OrderBean, NullWritable> {
    @Override
    public int getPartition(OrderBean orderBean, NullWritable nullWritable, int numPartitions) {
        //将每个订单的所有的记录，传入到一个reduce当中
        return orderBean.getOrderId().hashCode() % numPartitions;
    }
}

4、自定义分组类

import org.apache.hadoop.io.WritableComparable;
import org.apache.hadoop.io.WritableComparator;

//自定义分组类
public class MyGroup extends WritableComparator {
    public MyGroup() {
        //分组类：要对OrderBean类型的k进行分组
        super(OrderBean.class, true);
    }

    @Override
    public int compare(WritableComparable a, WritableComparable b) {
        OrderBean a1 = (OrderBean) a;
        OrderBean b1 = (OrderBean) b;
        //需要将同一订单的kv作为一组
        return a1.getOrderId().compareTo(b1.getOrderId());
    }
}

5、自定义reduce类

import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.mapreduce.Reducer;

import java.io.IOException;

public class GroupReducer extends Reducer<OrderBean, NullWritable, OrderBean, NullWritable> {

    /**
     * Order_0000002	Pdt_03	322.8
     * Order_0000002	Pdt_04	522.4
     * Order_0000002	Pdt_05	822.4
     * => 这一组中有3个kv
     * 并且是排序的
     * Order_0000002	Pdt_05	822.4
     * Order_0000002	Pdt_04	522.4
     * Order_0000002	Pdt_03	322.8
     *
     * @param key
     * @param values
     * @param context
     * @throws IOException
     * @throws InterruptedException
     */
    @Override
    protected void reduce(OrderBean key, Iterable<NullWritable> values, Context context) throws IOException, InterruptedException {
        //Order_0000002	Pdt_05	822.4 获得了当前订单中进而最高的商品
        //top1
        context.write(key, NullWritable.get());

        //top2
        //这样出不了正确结果，只会将同一个key输出两次;结果如下
        /*
        *
            Order_0000001	222.8
            Order_0000001	222.8
            Order_0000002	822.4
            Order_0000002	822.4
            Order_0000003	222.8
            Order_0000003	222.8
        * */
//        for(int i = 0; i < 2; i++){
//            context.write(key, NullWritable.get());
//        }

        //正确的做法：
//        int num = 0;
//        for(NullWritable value: values) {
//            context.write(key, value);
//            num++;
//            if(num == 2)
//                break;
//        }
    }
}

6、自定义程序入口类

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.conf.Configured;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;
import org.apache.hadoop.util.Tool;
import org.apache.hadoop.util.ToolRunner;

/**
 * 分组求top 1
 */
public class GroupMain extends Configured implements Tool {
    @Override
    public int run(String[] args) throws Exception {
        //获取job对象
        Job job = Job.getInstance(super.getConf(), "group");
        job.setJarByClass(GroupMain.class);

        //第一步：读取文件，解析成为key，value对
        job.setInputFormatClass(TextInputFormat.class);
        TextInputFormat.addInputPath(job, new Path(args[0]));

        //第二步：自定义map逻辑
        job.setMapperClass(GroupMapper.class);
        job.setMapOutputKeyClass(OrderBean.class);
        job.setMapOutputValueClass(NullWritable.class);

        //第三步：分区
        job.setPartitionerClass(GroupPartitioner.class);

        //第四步：排序  已经做了

        //第五步：规约  combiner  省掉

        //第六步：分组   自定义分组逻辑
        job.setGroupingComparatorClass(MyGroup.class);

        //第七步：设置reduce逻辑
        job.setReducerClass(GroupReducer.class);
        job.setOutputKeyClass(OrderBean.class);
        job.setOutputValueClass(NullWritable.class);

        //第八步：设置输出路径
        job.setOutputFormatClass(TextOutputFormat.class);
        TextOutputFormat.setOutputPath(job, new Path(args[1]));

        //如果设置reduce任务数为多个，必须打包到集群运行
        //mr中reduce个数，默认是1
//        job.setNumReduceTasks(1);
        //job.setNumReduceTasks(3);

        boolean b = job.waitForCompletion(true);
        return b ? 0 : 1;
    }

    public static void main(String[] args) throws Exception {
        int run = ToolRunner.run(new Configuration(), new GroupMain(), args);
        System.exit(run);
    }
}

11、map task工作机制
（1）Read阶段：MapTask通过用户编写的RecordReader，从输入InputSplit中解析出一个个key/value。
（2）Map阶段：该节点主要是将解析出的key/value交给用户编写map()函数处理，并产生一系列新的key/value。
（3）Collect收集阶段：在用户编写map()函数中，当数据处理完成后，一般会调用OutputCollector.collect()输出结果。在该函数内部，它会将生成的key/value分区（调用Partitioner），并写入一个环形内存缓冲区中。
（4）Spill阶段：即“溢写”，当环形缓冲区满80%后，MapReduce会将数据写到本地磁盘上，生成一个临时文件。需要注意的是，将数据写入本地磁盘之前，先要对数据进行一次本地排序，并在必要时对数据进行合并、压缩等操作。
溢写阶段详情：
- 步骤1：利用快速排序算法对缓存区内的数据进行排序，排序方式是，先按照分区编号Partition进行排序，然后按照key进行排序。这样，经过排序后，数据以分区为单位聚集在一起，且同一分区内所有数据按照key有序。
- 步骤2：按照分区编号由小到大依次将每个分区中的数据写入任务工作目录下的临时文件output/spillN.out（N表示当前溢写次数）中。如果用户设置了Combiner，则写入文件之前，对每个分区中的数据进行一次聚集操作。
- 步骤3：将分区数据的元信息写到内存索引数据结构SpillRecord中，其中每个分区的元信息包括，在临时文件中的偏移量、压缩前数据大小和压缩后数据大小。如果当前内存索引大小超过1MB，则将内存索引写到文件output/spillN.out.index中。
- （5）合并阶段：当所有数据处理完成后，MapTask对所有临时文件进行一次合并，以确保最终只会生成一个数据文件。
- 当所有数据处理完后，MapTask会将所有临时文件合并成一个大文件，并保存到文件output/file.out中，同时生成相应的索引文件output/file.out.index。
- 在进行文件合并过程中，MapTask以分区为单位进行合并。对于某个分区，它将采用多轮递归合并的方式。每轮合并io.sort.factor（默认10）个文件，并将产生的文件重新加入待合并列表中，对文件排序后，重复以上过程，直到最终得到一个大文件。
- 让每个MapTask最终只生成一个数据文件，可避免同时打开大量文件和同时读取大量小文件产生的随机读取带来的开销。

15. reduce task工作机制

1. reduce流程

（1）Copy阶段：ReduceTask从各个MapTask上远程拷贝一片数据，并针对某一片数据，如果其大小超过一定阈值，则写到磁盘上，否则直接放到内存中。
（2）Merge阶段：在远程拷贝数据的同时，ReduceTask启动了两个后台线程对内存和磁盘上的文件进行合并，以防止内存使用过多或磁盘上文件过多。
（3）Sort阶段：当所有map task的分区数据全部拷贝完，按照MapReduce语义，用户编写reduce()函数输入数据是按key进行聚集的一组数据。为了将key相同的数据聚在一起，Hadoop采用了基于排序的策略。由于各个MapTask已经实现对自己的处理结果进行了局部排序，因此，ReduceTask只需对所有数据进行一次归并排序即可。
（4）Reduce阶段：reduce()函数将计算结果写到HDFS上。

2. 设置ReduceTask并行度（个数）

ReduceTask的并行度同样影响整个Job的执行并发度和执行效率，但与MapTask的并发数由切片数决定不同，ReduceTask数量的决定是可以直接手动设置：

// 默认值是1，手动设置为4

job.setNumReduceTasks(4);

3. 实验：测试ReduceTask多少合适

（1）实验环境：1个Master节点，16个Slave节点：CPU:8GHZ，内存: 2G
（2）实验结论：
表4-3 改变ReduceTask （数据量为1GB）

MapTask =16
ReduceTask	1	5	10	15	16	20	25	30	45	60
总时间	892	146	110	92	88	100	128	101	145	104

16. mapreduce完整流程

1. map简图

2. reduce简图

3. mapreduce简略步骤

第一步：读取文件，解析成为key，value对
第二步：自定义map逻辑接受k1,v1，转换成为新的k2,v2输出；写入环形缓冲区
第三步：分区：写入环形缓冲区的过程，会给每个kv加上分区Partition index。（同一分区的数据，将来会被发送到同一个reduce里面去）
第四步：排序：当缓冲区使用80%，开始溢写文件
- 先按partition进行排序，相同分区的数据汇聚到一起；
- 然后，每个分区中的数据，再按key进行排序
第五步：combiner。调优过程，对数据进行map阶段的合并（注意：并非所有mr都适合combine）
第六步：将环形缓冲区的数据进行溢写到本地磁盘小文件
第七步：归并排序，对本地磁盘溢写小文件进行归并排序
第八步：等待reduceTask启动线程来进行拉取数据
第九步：reduceTask启动线程，从各map task拉取属于自己分区的数据
第十步：从mapTask拉取回来的数据继续进行归并排序
第十一步：进行groupingComparator分组操作
第十二步：调用reduce逻辑，写出数据
第十三步：通过outputFormat进行数据输出，写到文件，一个reduceTask对应一个结果文件

捡黄金的少年

关注

0
点赞
踩
6

收藏

觉得还不错? 一键收藏
1
评论
分布式计算模型MapReduce的学习

MapReduce是一个分布式运算程序的编程框架，是用户开发“基于Hadoop的数据分析应用”的核心框架。MapReduce核心功能是将用户编写的业务逻辑代码和自带默认组件整合成一个完整的分布式运算程序，并发运行在一个Hadoop集群上MapReduce是采用一种分而治之的思想设计出来的分布式计算框架那什么是分而治之呢？比如一复杂、计算量大、耗时长的的任务，暂且称为“大任务”；此时使用单台服务器无法计算或较短时间内计算出结果时，可将此大任务切分成一个个小的任务，小任务分别在不同的服务器上并行的执行；最终再汇
复制链接

扫一扫