hadoop 二次排序 group函数的作用的说明

最新推荐文章于 2022-10-27 00:25:54 发布
最新推荐文章于 2022-10-27 00:25:54 发布
阅读量622 收藏
点赞数
分类专栏： hadoop 大数据 mapreduce
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xuedingkai/article/details/78197354
版权
大数据 同时被 3 个专栏收录
9 篇文章 0 订阅
订阅专栏
hadoop
6 篇文章 0 订阅
订阅专栏
mapreduce
2 篇文章 0 订阅
订阅专栏

hadoop mapreduce作业通过组合key实现二次排序的过程中，只要实现组合key的类就可以了。mapreduce框架本身会基于key对输出进行排序。

而partion函数只为了是实现数据规模较大时，对map的输出实现分区。为启动多个reduce任务做准备。

group函数也是可有可无的。

group函数的作用是对key进行分组，例如对于map的结果：

[(k1, k21), v1]

[(k1, k22), v2]

[(k1, k23), v3]

通过设定group函数可以做到按组合key的k1进行分组：

[[(k1, k21), (k1, k22), (k1, k23)], [v1, v2, v3]]


下面验证结果记录：


输入文件file1：

1	2
6	4
1	4
2	5
3	1
4	3
2	6

输入文件file2： 

4	1
5	5
2	1
6	8
1	9
6	1

实现的完整代码： 

package hadoop;

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

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.KeyValue.RawBytesComparator;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.RawComparator;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.io.WritableComparable;
import org.apache.hadoop.io.WritableComparator;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Partitioner;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.util.GenericOptionsParser;

public class DDSort {
    public static class Map extends Mapper<LongWritable, Text, DataPair, IntWritable>{
        @Override
        protected void map(
                LongWritable key,
                Text value,
                Mapper<LongWritable, Text, DataPair, IntWritable>.Context context)
                throws IOException, InterruptedException {
            String str = value.toString();
            String [] sz = str.split("\t");
            if(sz.length == 2){
                int v1 = Integer.parseInt(sz[0]);
                int v2 = Integer.parseInt(sz[1]);
                DataPair dp = new DataPair(v1, v2);
                //context.write(new IntWritable(v1), new IntWritable(v2));
                context.write(dp, new IntWritable(v2));
            }
        }
    }
    
    public static class DataPair implements WritableComparable<DataPair> {
        private int v1;
        private int v2;
        
        public DataPair(){
            
        }
        
        public DataPair(int arg1, int arg2){
            v1 = arg1;
            v2 = arg2;
        }
        
        public int getV1() {
            return v1;
        }

        public void setV1(int v1) {
            this.v1 = v1;
        }

        public int getV2() {
            return v2;
        }

        public void setV2(int v2) {
            this.v2 = v2;
        }
        
        @Override
        public String toString() {
            return new Integer(v1).toString() + " " + new Integer(v2).toString(); 
        }

        @Override
        public void readFields(DataInput in) throws IOException {
            // TODO Auto-generated method stub
            v1 = in.readInt();
            v2 = in.readInt();
        }

        @Override
        public void write(DataOutput out) throws IOException {
            // TODO Auto-generated method stub
            out.writeInt(v1);
            out.writeInt(v2);
        }

        @Override
        public int compareTo(DataPair o) {
            int tmp = v1 - o.getV1();
            if(tmp != 0){
                return tmp;
            }
            return v2 - o.getV2();
        }
        
        
        static {
            //WritableComparator.define(DataPair.class, new Comparator());
        }
    }
    
//    public class Comparator extends WritableComparator{
//        public Comparator() {
//            super(DataPair.class);
//        }
//        
//        @Override
//        public int compare(byte[] arg0, int arg1, int arg2, byte[] arg3,
//                int arg4, int arg5) {
//            // TODO Auto-generated method stub
//            return super.compare(arg0, arg1, arg2, arg3, arg4, arg5);
//        }     
//    }
    
    public static class Prt extends Partitioner<DataPair, IntWritable>{
        @Override
        public int getPartition(DataPair arg0, IntWritable arg1, int arg2) {
            
            return arg0.getV1()%arg2;
        }
    }
    
    public static class Grp implements RawComparator<DataPair>{
        @Override
        public int compare(DataPair o1, DataPair o2) {
            return o1.v1 - o2.v1;
        }
        
        @Override
        public int compare(byte[] arg0, int arg1, int arg2, byte[] arg3,
                int arg4, int arg5) {

            return WritableComparator.compareBytes(arg0, arg1, 4, arg3, arg4, 4);
        }
    }
    
    public static class Grp1 extends WritableComparator{

        protected Grp1() {
            super(DataPair.class);
        }
        
        @Override
        public int compare(WritableComparable a, WritableComparable b) {
            DataPair d1 = (DataPair)a;
            DataPair d2 = (DataPair)b;
            return Integer.compare(d1.getV1(), d2.getV1());
        }
    }
    
    public static class Reduce extends Reducer<DataPair, IntWritable, DataPair, IntWritable>{
        @Override
        protected void reduce(
                DataPair key,
                Iterable<IntWritable> value,
                Reducer<DataPair, IntWritable, DataPair, IntWritable>.Context context)
                throws IOException, InterruptedException {
            //context.write(key, new IntWritable(1));
            int test = 1000; //for test
            for(IntWritable i : value){
                context.write(key, i);
            }
            System.out.println(++test); //for test
            context.write(key, new IntWritable(test)); //for test
        }
    }
    
    private static String inputPath = "in-ddsort";
    private static String outputPath = "out-ddsort";
    
    public static void main(String[] args) throws Exception {
        Configuration conf = new Configuration();
        String[] otherArgs = new GenericOptionsParser(conf, args)
                .getRemainingArgs();
        
        Job job = new Job(conf, "DDSort");
        job.setJarByClass(DDSort.class);
        job.setMapperClass(Map.class);
        job.setReducerClass(Reduce.class);
        
        job.setPartitionerClass(Prt.class);
        job.setNumReduceTasks(6);
        //job.setGroupingComparatorClass(Grp.class);
        
        job.setMapOutputKeyClass(DataPair.class);
        job.setMapOutputValueClass(IntWritable.class);
        job.setOutputKeyClass(DataPair.class);
        job.setOutputValueClass(IntWritable.class);
        
        
        FileSystem fs = FileSystem.get(conf);
        Path outPath = new Path(outputPath);
        if (fs.exists(outPath)) {
            fs.delete(outPath, true);
        }
        
        FileInputFormat.addInputPath(job, new Path(inputPath));
        FileOutputFormat.setOutputPath(job, new Path(outputPath));
        System.exit(job.waitForCompletion(true) ? 0 : 1);
    }
}



1、不配值partition和group函数的情况：

	public static void main(String[] args) throws Exception {
        Configuration conf = new Configuration();
        String[] otherArgs = new GenericOptionsParser(conf, args)
                .getRemainingArgs();
        if (otherArgs.length != 2) {
            System.err.println("Usage: wordcount <in> <out>");
            System.exit(2);
        }
        Job job = new Job(conf, "DDSort");
        job.setJarByClass(DDSort.class);
        job.setMapperClass(Map.class);
        job.setReducerClass(Reduce.class);
        
        //job.setPartitionerClass(Prt.class);
        //job.setNumReduceTasks(6);
        //job.setGroupingComparatorClass(Grp.class);
        
        job.setMapOutputKeyClass(DataPair.class);
        job.setMapOutputValueClass(IntWritable.class);
        job.setOutputKeyClass(DataPair.class);
        job.setOutputValueClass(IntWritable.class);
        FileInputFormat.addInputPath(job, new Path(otherArgs[0]));
        FileOutputFormat.setOutputPath(job, new Path(otherArgs[1]));
        System.exit(job.waitForCompletion(true) ? 0 : 1);
    }

对应的输出结果为只有一个输出文件：

-rw-r--r--   3 root supergroup          0 2017-10-10 21:02 /user/root/out-ddsort21/_SUCCESS
drwxr-xr-x   - root supergroup          0 2017-10-10 21:01 /user/root/out-ddsort21/_logs
-rw-r--r--   3 root supergroup         78 2017-10-10 21:02 /user/root/out-ddsort21/part-r-00000
part-r-00000内容为：

1    2    2
1    2    1001
1    4    4
1    4    1001
1    9    9
1    9    1001
2    1    1
2    1    1001
2    5    5
2    5    1001
2    6    6
2    6    1001
3    1    1
3    1    1001
4    1    1
4    1    1001
4    3    3
4    3    1001
5    5    5
5    5    1001
6    1    1
6    1    1001
6    4    4
6    4    1001
6    8    8
6    8    1001

可见一个[(k1, k21), v1]属于一组。

2、只配置partion

	public static void main(String[] args) throws Exception {
        Configuration conf = new Configuration();
        String[] otherArgs = new GenericOptionsParser(conf, args)
                .getRemainingArgs();
        if (otherArgs.length != 2) {
            System.err.println("Usage: wordcount <in> <out>");
            System.exit(2);
        }
        Job job = new Job(conf, "DDSort");
        job.setJarByClass(DDSort.class);
        job.setMapperClass(Map.class);
        job.setReducerClass(Reduce.class);
        
        job.setPartitionerClass(Prt.class);
        job.setNumReduceTasks(6);
        //job.setGroupingComparatorClass(Grp.class);
        
        job.setMapOutputKeyClass(DataPair.class);
        job.setMapOutputValueClass(IntWritable.class);
        job.setOutputKeyClass(DataPair.class);
        job.setOutputValueClass(IntWritable.class);
        FileInputFormat.addInputPath(job, new Path(otherArgs[0]));
        FileOutputFormat.setOutputPath(job, new Path(otherArgs[1]));
        System.exit(job.waitForCompletion(true) ? 0 : 1);
    }

对应的输出结果为：

Found 8 items
-rw-r--r--   3 root supergroup          0 2017-10-10 21:34 /user/root/out-ddsort22/_SUCCESS
drwxr-xr-x   - root supergroup          0 2017-10-10 21:33 /user/root/out-ddsort22/_logs
-rw-r--r--   3 root supergroup         18 2017-10-10 21:33 /user/root/out-ddsort22/part-r-00000
-rw-r--r--   3 root supergroup         18 2017-10-10 21:33 /user/root/out-ddsort22/part-r-00001
-rw-r--r--   3 root supergroup         18 2017-10-10 21:33 /user/root/out-ddsort22/part-r-00002
-rw-r--r--   3 root supergroup          6 2017-10-10 21:33 /user/root/out-ddsort22/part-r-00003
-rw-r--r--   3 root supergroup         12 2017-10-10 21:33 /user/root/out-ddsort22/part-r-00004
-rw-r--r--   3 root supergroup          6 2017-10-10 21:33 /user/root/out-ddsort22/part-r-00005

part-r-00000：

6    1    1
6    1    1001
6    4    4
6    4    1001
6    8    8
6    8    1001

part-r-00001：

1    2    2
1    2    1001
1    4    4
1    4    1001
1    9    9
1    9    1001

part-r-00003：

2    1    1
2    1    1001
2    5    5
2    5    1001
2    6    6
2    6    1001

.......

可见一个[(k1, k21), v1]属于一组。


3、配置partiton和group

    public static void main(String[] args) throws Exception {
        Configuration conf = new Configuration();
        String[] otherArgs = new GenericOptionsParser(conf, args)
                .getRemainingArgs();
        if (otherArgs.length != 2) {
            System.err.println("Usage: wordcount <in> <out>");
            System.exit(2);
        }
        Job job = new Job(conf, "DDSort");
        job.setJarByClass(DDSort.class);
        job.setMapperClass(Map.class);
        job.setReducerClass(Reduce.class);
        
        job.setPartitionerClass(Prt.class);
        job.setNumReduceTasks(6);
        job.setGroupingComparatorClass(Grp.class);
        
        job.setMapOutputKeyClass(DataPair.class);
        job.setMapOutputValueClass(IntWritable.class);
        job.setOutputKeyClass(DataPair.class);
        job.setOutputValueClass(IntWritable.class);
        FileInputFormat.addInputPath(job, new Path(otherArgs[0]));
        FileOutputFormat.setOutputPath(job, new Path(otherArgs[1]));
        System.exit(job.waitForCompletion(true) ? 0 : 1);
    }

输出结果：

Found 8 items
-rw-r--r--   3 root supergroup          0 2017-10-10 22:04 /user/root/out-ddsort23/_SUCCESS
drwxr-xr-x   - root supergroup          0 2017-10-10 22:03 /user/root/out-ddsort23/_logs
-rw-r--r--   3 root supergroup         18 2017-10-10 22:03 /user/root/out-ddsort23/part-r-00000
-rw-r--r--   3 root supergroup         18 2017-10-10 22:03 /user/root/out-ddsort23/part-r-00001
-rw-r--r--   3 root supergroup         18 2017-10-10 22:03 /user/root/out-ddsort23/part-r-00002
-rw-r--r--   3 root supergroup          6 2017-10-10 22:03 /user/root/out-ddsort23/part-r-00003
-rw-r--r--   3 root supergroup         12 2017-10-10 22:03 /user/root/out-ddsort23/part-r-00004
-rw-r--r--   3 root supergroup          6 2017-10-10 22:03 /user/root/out-ddsort23/part-r-00005

part-r-00000：

6    1    1
6    4    4
6    8    8
6    8    1001

part-r-00001：

1    2    2
1    4    4
1    9    9
1    9    1001

part-r-00002：

2    1    1
2    5    5
2    6    6
2    6    1001

.......

可见k1相同的属于一组，以下的属于同一组：

[(k1, k21), v1]

[(k1, k22), v2]

[(k1, k23), v3]

这就是group函数的作用。


注意：

    public static class Reduce extends Reducer<DataPair, IntWritable, DataPair, IntWritable>{
        @Override
        protected void reduce(
                DataPair key,
                Iterable<IntWritable> value,
                Reducer<DataPair, IntWritable, DataPair, IntWritable>.Context context)
                throws IOException, InterruptedException {
            //context.write(key, new IntWritable(1));
            int test = 1000; //for test
            for(IntWritable i : value){ //只迭代了value
                context.write(key, i);
            }
            System.out.println(++test); //for test
            context.write(key, new IntWritable(test)); //for test
        }
    }
此处只迭代了value，可从输出来看，for循环中key的值也发生了变化!?

不明白为什么，若哪位知道原因欢迎留言，谢谢。

古巴与八股
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
hadoop二次排序的原理和实现方法
10-16
二次排序在Hadoop中主要涉及Map、Reduce阶段以及自定义类的实现。 1. 二次排序原理： - Map阶段：Map任务接收输入数据，将其切分为多个Split，由InputFormat的RecordReader将数据读取并转化为键值对（通常是, Text...
hadoop分区二次排序示例.zip
12-27
在这个“hadoop分区二次排序示例.zip”压缩包中，我们重点探讨的是如何在Hadoop MapReduce中实现特定的排序逻辑，即二次排序和分区策略。 首先，我们需要理解什么是二次排序。在标准的MapReduce流程中，数据经过map...
python group()
weixin_34049032的博客
08-20 1715
正则表达式中，group（）用来提出分组截获的字符串，（）用来分组 import re a = "123abc456" print re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(0) #123abc456,返回整体 print re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(1) #123...
Hadoop 二次排序
857技术社区
06-30 254
具体步骤： 1 自定义key。 在mr中，所有的key是需要被比较和排序的，并且是二次，先根据partitioner，再根据大小。而本例中也是要比较两次。先按照第一字段排序，然后再对第一字段相同的按照第二字段排序。根据这一点，我们可以构造一个复合类IntPair，他有两个字段，先利用分区对第一字段排序，再利用分区内的比较对第二字段排序。 所有自定义的key应该实现接口WritableComparable，因为是可序列的并且可比较的。并重载方法 //反序列化，从流中的二进制转换成IntPair public
python中group()函数的用法
m0_73846634的博客
10-27 4022
转载于:https://www.cnblogs.com/engineering-drawing/p/10263173.html。2. 没有匹配成功的，re.search（）返回None。1. 正则表达式中的三组括号把匹配结果分成三组。中，group（）用来提出分组截获的字符串。
不容忽视的setJarByClass方法——找不到Map类
sun_168的专栏
06-04 9284
如果集群上运行程序找不到Map和Reduce类一般都是没有设置包含类的Jar包 API解析如下： setJarByClasspublic void setJarByClass(Class cls) Set the Jar by finding where a given class came from. Parameters:cls - the example class
【Pytorch】的函数中的group参数的作用
mjiansun的专栏
07-09 2563
官方的api介绍：https://pytorch.org/docs/stable/nn.html?highlight=nn conv2d#torch.nn.Conv2d 1.当设置group=1时： conv = nn.Conv2d(in_channels=6, out_channels=6, kernel_size=1, groups=1) conv.weight.data.size() ...
hadoop实现分区二次排序代码示例.zip
12-27
在大数据处理领域，Hadoop是一个不可或缺的开源框架，它提供了分布式存储和计算的能力。本示例中的"had
hadoop 二次排序 原理
03-19
本文将深入解析Hadoop的二次排序（Secondary Sort）原理，这是一个允许用户自定义排序规则以满足特定需求的功能。 首先，二次排序是在MapReduce框架内进行的一种特殊排序方式，它遵循两个主要步骤：第一字段排序和...
Hadoop二次开发必懂
03-01
【Hadoop二次开发必懂】深入理解MapReduce 在Hadoop的世界中，MapReduce是一种分布式计算模型，用于处理和生成大规模数据集。它基于“分而治之”的理念，将大任务拆解为一系列可并行执行的小任务，极大地提高了处理...
DDSort一个简单的轻量级的拖拽排序jQuery插件
08-09
DDSort.js是一款简单实用的jQuery拖拽排序插件。通过该插件你可以任意拖动页面中元素，并放置到指定的地方。DDSort.js插件实用简单，兼容IE8浏览器。
DDSort, 一个简单轻量级的拖放排序jQuery插件.zip
09-18
DDSort, 一个简单轻量级的拖放排序jQuery插件 DDSort <div class="wrap"> <ul> <li>...</li> <li>...</li>. . .
DDSort-简单实用的jQuery拖拽排序插件
12-11
DDSort.js是一款简单实用的jQuery拖拽排序插件。通过该插件你可以任意拖动页面中元素，并放置到指定的地方。DDSort.js插件实用简单，兼容IE8浏览器。
hadoop的Group Comparator
allen的博客
10-09 1910
最近看dadoop中关于辅助排序（SecondarySort）的实现，说到了三个东西要设置：1. partioner；2. Key Comparator；3. Group Comparator。前两个都比较容易理解，但是关于group的概念我一直理解不了，一，有了partioner，所有的key已经放到一个分区了，每个分区对应一个reducer，而且key也可以排序了，那么不是实现了整个数据集的全排
hadoop的分组实现
一个人的世界
12-10 454
https://www.cnblogs.com/edisonchou/p/4297828.html
Hadoop3集群搭建之——安装hadoop，配置环境
anfuyi5792的博客
04-24 256
　　接上篇：Hadoop3集群搭建之——虚拟机安装 　　下篇：Hadoop3集群搭建之——配置ntp服务 　　　　Hadoop3集群搭建之——hive安装 　　　　Hadoop3集群搭建之——hbase安装及简单操作 上篇已经安装好了虚拟机了，现在开始配置环境，安装hadoop 注：hadoop集群最少需要三台机，因为hdfs副本数最少为3，单机不算 　　我搭了三台机 ...
Hadoop框架排序和分组的理解
坐禅小和尚的专栏
05-28 7231
MapReduce框架会确保每一个Reducer的输入都是按Key进行排序的。一般，将排序以及Map的输出传输到Reduce的过程称为混洗（shuffle)。每一个Map都包含一个环形的缓存，默认100M，Map首先将输出写到缓存当中。当缓存的内容达到“阈值”时（阈值默认的大小是缓存的80%），一个后台线程负责将结果写到硬盘，这个过程称为“spill”。Spill过程中，Map仍可以向缓存写入结果
自定义-Hadoop自定义分组Group
u011007180的博客
08-21 1955
自定义分组MyGroup： 主要是继承WritableComparator类，重写compare函数 我这里重写的是该源码函数： [java] view plain copy print? /** Compare two WritableComparables.    *    *  The default implementation uses
一个Hadoop工程关于温度的二次排序程序
最新发布
03-14
可以使用MapReduce框架来实现Hadoop工程关于温度的二次排序程序。具体实现方法如下： 1. Mapper阶段：将输入的数据按照温度值和时间戳进行分割，将温度值作为Key，将时间戳和温度值作为Value输出。 2. Shuffle阶段...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值