通过hadoop二次排序分析hadoop工作过程

最新推荐文章于 2020-06-30 15:29:14 发布
最新推荐文章于 2020-06-30 15:29:14 发布
阅读量498 收藏 1
点赞数 1
分类专栏： hadoop 文章标签： hadoop mapreduce
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013735511/article/details/75738661
版权

1.什么是hadoop，可以做什么
        hadoop是Apache基金会开发的分布式系统基础架构，可以开发和运行大规模数据的软件平台。Hadoop有两个重要模块，HDFS与MapReduce。
      HDFS是Hadoop的分布式存储平台，对于hadoop集群，拥有namenode和datanode节点。namenode节点职责是对存储系统进行控制，想一想namenode可以控制整个集群，是不是任务重大呢？所以我们需要避免namenode出现单点故障，因此我们可以再用一台namenode机器然后使用zookeeper配置主备，当主namenode出故障时候，备用namenode可以及时顶起任务。我们阅读其它关于hadoop的内容会发现集群还会有一个SecondNameNode节点，那么SecondNameNode节点的作用是什么呢？SecondNameNode职责在于对namenode产生的日志文件进行合并。
      MapReduce是集群的分布式计算平台。这个平台在老版本中的角色是jobtracker和tasktracker；在新版本中的角色有ResourceManager和NodeManager。我们以新版本的角色为例分析MapReduce过程。

a. 客户端向ResourceManager申请作业ID，将作业需要的jar文件、配置信息和分片信息上传到hdfs上面。数据分片信息决定了ResourceManager需要为该作业启动多少个map任务，而reduce任务数目则在集群配置信息中指定。
b. 完成后提交任务，ResourceManager开始执行任务
c. ResourceManager首先初始化任务，创建作业对象，将任务放置调度器中；然后向hdfs请求处理数据的详细描述信息
d. NodeManager向ResourceManager领取自己的具体任务描述，在hdfs取回运行时数据，在本地启动JVM虚拟机运行子进程。
e. 在任务运行的同时，一个NodeManager启动MRAppMaster进程，这个进程获取所有任务信息，并汇集任务完成情况向ResourceManager汇报。
f. reduce完成后结果输入到hdfs

2.什么是hadoop的二次排序
      所谓二次排序，就是对第一个字段进行排序，对第二个字段进行排序。根据二次排序我们也可以实现三次排序。对于hadoop来说，默认情况下会进行一次排序，也就是对第一个字段进行排序。

3.hadoop怎样做二次排序
      上面有讲到MapReduce的流程，我们分析下二次排序的流程。MapReduce会先对原始文件进行分片，每个分片对应着一个map过程。中间经过环形缓冲区的排序，分区，自定义二次排序，合并，shuffle后传到reduce阶段；在reduce阶段，将不同源头的数据合并后会按照key值进行分组，每处理完一个分组后调用reduce函数，输出结果。
      解决思路：
      我们指导MapReduce的排序总会对key进行排序，在数据不是key的情况下，我们需要将其变为key值，因此我们需要将key，value组合成一个key值，即(k，v) -> v

4.二次排序代码

客户端代码

package job;

import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;

import mapper.SortMapper;

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

import reducer.SortReducer;
import util.Group;
import util.KVPair;
import util.MyCompare;
import util.MyPartition;

import com.sun.xml.internal.ws.policy.privateutil.PolicyUtils.Text;

public class MyJob {

    private static final String INPUT = "hdfs://master:9000/test.txt";

    private static final String OUTPUT = "hdfs://master:9000/out.txt";

    public static void main(String args[]) {

        Configuration conf = new Configuration();
        try {
            FileSystem fs = FileSystem.get(new URI(OUTPUT), conf);
            if(fs.exists(new Path(OUTPUT))) {
                fs.delete(new Path(OUTPUT), true);
            }

            Job job = new Job(conf, MyJob.class.getName());
            FileInputFormat.setInputPaths(job, INPUT);
//          job.setInputFormatClass(KeyValueTextInputFormat.class);
            job.setMapperClass(SortMapper.class);
            job.setMapOutputKeyClass(KVPair.class);
            job.setMapOutputValueClass(IntWritable.class);

            job.setPartitionerClass(MyPartition.class);
            job.setNumReduceTasks(1);

            job.setGroupingComparatorClass(Group.class);
            job.setSortComparatorClass(MyCompare.class);

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

            FileOutputFormat.setOutputPath(job, new Path(OUTPUT));
            System.exit(job.waitForCompletion(true)?0:1);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (URISyntaxException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

mapper代码

package mapper;

import java.io.IOException;

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

import util.KVPair;

public class SortMapper extends Mapper<Object, Text, KVPair, IntWritable> {

    @Override
    protected void map(Object key, Text value, Context context) throws IOException, InterruptedException {

        if(null == value) return;
        System.out.println("--------------enter map--------------");

        String[] it = value.toString().split(" ");
        KVPair kv = new KVPair(); IntWritable v = null;
        Text t = new Text();
        if(it.length == 2){

            t.set(it[0]);
            kv.setKey(t);
            v = new IntWritable(Integer.valueOf(it[1]));
            kv.setValue(v);
            context.write(kv, v);
        }
        System.out.println("--------------end map--------------");
    }

}

reduce代码

package reducer;

import java.io.IOException;

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

import util.KVPair;

public class SortReducer extends Reducer<KVPair, IntWritable, Text, Text>{

    @Override
    protected void reduce(KVPair key, Iterable<IntWritable> value, Context context) throws IOException, InterruptedException {

        System.out.println("--------------enter reduce----------------");
        StringBuilder sb = new StringBuilder();
        for(IntWritable v : value) {

            sb.append(v.get()  + ",");
        }
        if(sb.length() > 0) {
            sb.deleteCharAt(sb.length()-1);
        }
        Text t = new Text();
        t.set(sb.toString());
        context.write(key.getKey(), t);
        System.out.println("--------------end reduce----------------");
    }


}

kv组合代码（因为在Job类中设置了比较器，所以这个类中的compare方法未实现）

package util;

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

import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.io.WritableComparable;

public class KVPair implements WritableComparable<KVPair>{

    Text key;
    IntWritable value;

    public KVPair() {
        this.key = new Text();
        this.value = new IntWritable();
    }

    public Text getKey() {
        return key;
    }
    public void setKey(Text key) {
        this.key = key;
    }
    public IntWritable getValue() {
        return value;
    }
    public void setValue(IntWritable value) {
        this.value = value;
    }

    @Override
    public void readFields(DataInput in) throws IOException {

        if(null == key)
            try {
                throw new Exception("key is null");
            } catch (Exception e) {
                e.printStackTrace();
            } 
        this.key.readFields(in);
        this.value.readFields(in);
    }
    @Override
    public void write(DataOutput out) throws IOException {

        this.key.write(out);
        this.value.write(out);
    }
    @Override
    public int compareTo(KVPair o) {
        // TODO Auto-generated method stub
        return 0;
    }

    @Override
    public String toString() {
        return "KVPair [key=" + key + ", value=" + value + "]";
    }
}

比较器

package util;

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

public class MyCompare extends WritableComparator {

    protected MyCompare(){
        super(KVPair.class, true);
    }

    @Override
    public int compare(WritableComparable a, WritableComparable b) {

        System.out.println("--------enter sort---------");
        KVPair k1 = (KVPair) a;
        KVPair k2 = (KVPair) b;
        int minus = k1.getKey().compareTo(k2.getKey());
        System.out.println("--------end sort---------");
        if(minus != 0) {

            return minus;
        } else {

            return k1.getValue().compareTo(k2.getValue());
        }
    }


}

分区代码

package util;

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

public class MyPartition extends Partitioner<KVPair, IntWritable> {

    @Override
    public int getPartition(KVPair key, IntWritable vale, int num) {


        System.out.print("-----enter partition-----");
        System.out.print("-----end partition-----");
        return (key.getKey().hashCode()) % num;

    }

}

分组代码

package util;

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

public class Group extends WritableComparator {

    protected Group() {
        super(KVPair.class, true);
    }

    @Override
    public int compare(WritableComparable a, WritableComparable b) {

        System.out.println("--------enter group---------");
        KVPair k1 = (KVPair) a;
        KVPair k2 = (KVPair) b;
        System.out.println("--------end group---------");
        return k1.getKey().compareTo(k2.getKey());
    }

}

输入

a 1
a 2
a 3
a 4
b 5
b 3
b 8
b 0
c 10
c 4
c 6
c 8
c 2
c 1
c 5
c 2
d 10
d 4
d 5
d 8
d 8
d 10
e 4
e 4
e 10
e 3
e 2

结果展示

a   1,2,3,4
b   0,3,5,8
c   1,2,2,4,5,6,8,10
d   4,5,8,8,10,10
e   2,3,4,4,10

代码注意点：需要将hadoop下面的jar包导入，否则会出现noClassDefFoundError

参考内容：
1. http://blog.csdn.net/lzm1340458776/article/details/42875751
2. hadoop权威指南第二版

Stray_Cat_Founder
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Hadoop的二次排序的个人理解（记录六）
weixin_42522212的博客
01-14 199
（以hadoop权威指南的年份和温度为例，key是年份，value是温度。） 个人理解 ：把key和value的值组合在一起，变成组合key，（称为ComposeKey）,再根据原先的key值，把组合key放到同一个分区，这是组合key的作用就显现了，value也会和原始key一起进入同一个分区，然后设置一个分组，使得同一年的温度在一个组里，即原始key相同的在一个分组里。（需要注意的是：同一个...
hadoop二次排序理解实战
fantasticqiang的博客
06-08 1406
描述MapReduce框架对处理结果的输出会根据key值进行默认的排序，这个默认排序可以满足一部分需求，但是也是十分有限的。在我们实际的需求当中，往往有要对reduce输出结果进行二次排序的需求。输入数据1 -12 2 -20 3 10 4 -5 5 15 1 20 2 30 3 40 4 25 5 30 1 40 2 41 3 42 4 43 5 44 1 -30 2 -31 3 -32 4 -...
hadoop二次排序流程实例详解
笨鸟快飞的专栏
08-05 849
一、概述     MapReduce框架对处理结果的输出会根据key值进行默认的排序，这个默认排序可以满足一部分需求，但是也是十分有限的。在我们实际的需求当中，往往有要对reduce输出结果进行二次排序的需求。对于二次排序的实现，网络上已经有很多人分享过了，但是对二次排序的实现的原理以及整个MapReduce框架的处理流程的分析还是有非常大的出入，而且部分分析是没有经过验证的。本文将通过一个实际
Hadoop 实验：二次排序
qq_43388040的博客
11-26 361
一．实验原理 MR默认会对键进行排序，然后有的时候我们也有对值进行排序的需要，如果有内存溢出的问题，就用二次排序来进行对值的排序MR计算过程中，而不是单独来做。 二次排序就是首先按照第一次字段排序，然后对第一字段相同的行按照第二字段排序，注意不能破坏第一次排序结果。 二．实验需要 本实验所需外部 jar 文件都可以在实验集群的/home/hadoop/lib.zip 文件中找到，请自行下载。 1....
Hadoop二次排序
ecjtusbs的博客
11-22 412
问题描述： 对如下的数据，进行排序，要求不同年龄的数据分为一组，同龄的数据按照身高升序排列。 。 大白话：左列为“年龄”，右列为“身高”。当然这里数据范围明显不合常理，但与本文关注重点无关，忽略。 问题分析 这
hadoop分区二次排序示例.zip
12-27
在这个“hadoop分区二次排序示例.zip”压缩包中，我们重点探讨的是如何在Hadoop MapReduce中实现特定的排序逻辑，即二次排序和分区策略。 首先，我们需要理解什么是二次排序。在标准的MapReduce流程中，数据经过map...
hadoop二次排序的原理和实现方法
10-16
二次排序在Hadoop中主要涉及Map、Reduce阶段以及自定义类的实现。 1. 二次排序原理： - Map阶段：Map任务接收输入数据，将其切分为多个Split，由InputFormat的RecordReader将数据读取并转化为键值对（通常是, Text...
hadoop实现分区二次排序代码示例.zip
12-27
在大数据处理领域，Hadoop是一个不可或缺的开源框架，它提供了分布式存储和计算的能力。本示例中的"had
hadoop 二次排序 原理
03-19
在Hadoop MapReduce的早期版本（0.20.0之前），二次排序通常通过设置`setPartitionerClass`、`setOutputKeyComparatorClass`和`setOutputValueGroupingComparator`来实现。而在0.20.0及之后的版本，这些设置被替换为...
Hadoop二次开发必懂
03-01
【Hadoop二次开发必懂】深入理解MapReduce 在Hadoop的世界中，MapReduce是一种分布式计算模型，用于处理和生成大规模数据集。它基于“分而治之”的理念，将大任务拆解为一系列可并行执行的小任务，极大地提高了处理...
（Hadoop学习－2）mapreduce实现二次排序
06-13 619
mapreduce实现二次排序
对Hadoop二次排序的理解
11-11 1万+
MR默认会对键进行排序，然而有的时候我们也有对值进行排序的需求。满足这种需求一是可以在reduce阶段排序收集过来的values，但是，如果有数量巨大的values可能就会导致内存溢出等问题，这就是二次排序应用的场景——将对值的排序也安排到MR计算过程之中，而不是单独来做。 首先我们要了解java中排序的机制，在java中一切都是对象，而在我们的基本数据类型中都有本类的比较策略，这样任何
hadoop 二次排序
modiziri的专栏
08-15 849
KeyFieldBasedPartitioner是Hadoop库中的一个实用Partitioner，配置相应的参数就可以使用，通过KeyFieldBasedPartitioner可以方便地实现二次排序。　 　　 $HADOOP_HOME/bin/hadoop streaming \        -D stream.map.output.field.separator=.
hadoop二次排序详解
Vikey2233
04-04 2469
1.定义 mapreduce计算过程中的输出Key-Value，都是按key自动排序，此为一次排序。 如果既要按key作第一排序，同时把value作第二排序的方式，称为二次排序。 如图所示： 2.工作流程图（按value降序） 3.核心思想 将map端输出的 package com.tl.core.secondsort; import java.io.DataInput; i...
hadoop二次排序解析
csdn问鼎
06-27 540
二次排序思路分析 试验数据 100 12 100 23 100 9 101 32 101 30 99 23 99 20 2.定义数据类型intpair,第一个数字为first,第二个数字为secondpublic static class IntPair implements WritableComparable<IntPair> { int first;
Hadoop二次排序关键点和出现时机（也叫辅助排序、Secondary Sort）
The Big Data Way
12-16 220
前言     Hadoop二次排序简单说就是先根据字段A分组排序，然后在对组内根据字段B排序。Hadoop二次排序在面试的时候出现频率也是比较高的。今天花了点时间通过源码深入学习了一下。（后面内容以Hadoop自带实例——SecondarySort讲解，见本文附录）     Hadoop默认是根据reduce key排序，通过Hadoop二次排序可以实现根据value值（需要将其放入复合k...
Hadoop之二次排序
gznc_pcc的博客
05-09 449
一、基本概念 二次排序就是首先按照第一字段排序，然后再对第一字段相同的行按照第二字段排序，注意不能破坏第一次排序的结果。 二、测试数据（部分） 1 5 1 3 1 4 1 99 2 400 2 240 2 237 2 238 2 239 2 245 三、输出数据（部分） --------------------------------------...
Hadoop 二次排序
857技术社区
06-30 254
具体步骤： 1 自定义key。 在mr中，所有的key是需要被比较和排序的，并且是二次，先根据partitioner，再根据大小。而本例中也是要比较两次。先按照第一字段排序，然后再对第一字段相同的按照第二字段排序。根据这一点，我们可以构造一个复合类IntPair，他有两个字段，先利用分区对第一字段排序，再利用分区内的比较对第二字段排序。 所有自定义的key应该实现接口WritableComparable，因为是可序列的并且可比较的。并重载方法 //反序列化，从流中的二进制转换成IntPair public
Hadoop二次排序及MapReduce处理流程实例详解
热门推荐
lavimer
01-19 1万+
一、概述 MapReduce框架对处理结果的输出会根据key值进行默认的排序，这个默认排序可以满足一部分需求，但是也是十分有限的，在我们实际的需求当中，往往有要对reduce输出结果进行二次排序的需求。对于二次排序的实现，网络上已经有很多人分享过了，但是对二次排序的实现原理及整个MapReduce框架的处理流程的分析还是有非常大的出入，而且部分分析是没有经过验证的。本文将通过一个实际的MapRe
一个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、付费专栏及课程。

余额充值