Hadoop mapreduce自定义排序WritableComparable

最新推荐文章于 2024-04-30 00:18:16 发布
最新推荐文章于 2024-04-30 00:18:16 发布
阅读量1.2k 收藏 1
点赞数 1
分类专栏： __MapReduce

  • 本文发表于本人博客。

        今天继续写练习题，上次对分区稍微理解了一下，那根据那个步骤分区、排序、分组、规约来的话，今天应该是要写个排序有关的例子了，那好现在就开始！

         说到排序我们可以查看下hadoop源码里面的WordCount例子中对LongWritable类型定义，它实现抽象接口WritableComparable，代码如下：

    1. public interface WritableComparable<T> extends Writable, Comparable<T> {
    2. }
    3. public interface Writable {
    4. void write(DataOutput out) throws IOException;
    5. void readFields(DataInput in) throws IOException;
    6. }

    其中Writable抽象接口定义了write以及readFields方法，分别是写入数据流以及读取数据流。而Comparable中又有compareTo方法定义比较。竟然hadoop的内置类型有比较大小功能，那么它使用这个内置类型作为map端输出的话是怎么样去排序的，这个问题我们先来查看下map任务类MapTask源代码，内部有内置MapOutputBuffer类，在spill accounting注释下面有个排序字段：

    1. private final IndexedSorter sorter;

    这个字段是由：

    1. sorter = ReflectionUtils.newInstance(job.getClass('map.sort.class', QuickSort.class, IndexedSorter.class), job);

    可以看出，这个排序算法可以在配置文件中指定，不过默认是快速排序QuickSort。这个QuickSort内部有几个重要的方法：

    1. public void sort(final IndexedSortable s, int p, int r,final Progressable rep);
    2. private static void sortInternal(final IndexedSortable s, int p, int r,final Progressable rep, int depth);

    其中在传递参数IndexSortable的时候是用MapOutputBuffer当前来传递，因为这个MapOutputBuffer也继承IndexedSortable.这样在QuickSort排序sort中就会使用MapOutputBuffer类中的compare方法进行比较，可以看下面源代码：

    01. public int compare(int i, int j) {
    02. final int ii = kvoffsets[i % kvoffsets.length];
    03. final int ij = kvoffsets[j % kvoffsets.length];
    04. // sort by partition
    05. if (kvindices[ii + PARTITION] != kvindices[ij + PARTITION]) {
    06. return kvindices[ii + PARTITION] - kvindices[ij + PARTITION];
    07. }
    08. // sort by key
    09. return comparator.compare(kvbuffer,
    10. kvindices[ii + KEYSTART],
    11. kvindices[ii + VALSTART] - kvindices[ii + KEYSTART],
    12. kvbuffer,
    13. kvindices[ij + KEYSTART],
    14. kvindices[ij + VALSTART] - kvindices[ij + KEYSTART]);
    15. }

    然而这个方法中comparator默认是由节点“mapred.output.key.comparator.class”决定，也可以看源码：

    1. public RawComparator getOutputKeyComparator() {
    2. Class<? extends RawComparator> theClass = getClass('mapred.output.key.comparator.class',
    3. null, RawComparator.class);
    4. if (theClass != null)
    5. return ReflectionUtils.newInstance(theClass, this);
    6. returnWritableComparator.get(getMapOutputKeyClass().asSubclass(WritableComparable.class));
    7. }

    就是这样把排序以及比较方法关联起来了！那现在我们可以按照LongWritable的思路实现自己的自定义类型并且读取、写入、比较。下面写写代码加深下记忆，既然是排序那我们准备下数据，如下有2列数据要求按照第一列升序，第二列降序排序：

    1. 1    2
    2. 1    1
    3. 3    0
    4. 3    2
    5. 2    2
    6. 1    2

    先自定义类型SortAPI：

    01. public class SortAPI implements WritableComparable<SortAPI> {
    02. /**
    03. * 第一列数据
    04. */
    05. public Long first;
    06. /**
    07. * 第二列数据
    08. */
    09. public Long second;
    10.  
    11. public SortAPI(){}
    12. public SortAPI(long first,long second){
    13. this.first = first;
    14. this.second = second;
    15. }
    16. /**
    17. * 排序就在这里当：this.first - o.first > 0 升序，小于0倒序
    18. */
    19. @Override
    20. public int compareTo(SortAPI o) {
    21. long mis = (this.first - o.first);
    22. if(mis != 0 ){
    23. return (int)mis;
    24. }
    25. else{
    26. return (int)(this.second - o.second);
    27. }
    28. }
    29.  
    30. @Override
    31. public void write(DataOutput out) throws IOException {
    32. out.writeLong(first);
    33. out.writeLong(second);
    34. }
    35.  
    36. @Override
    37. public void readFields(DataInput in) throws IOException {
    38. this.first = in.readLong();
    39. this.second = in.readLong();
    40.  
    41. }
    42.  
    43. @Override
    44. public int hashCode() {
    45. return this.first.hashCode() + this.second.hashCode();
    46. }
    47.  
    48. @Override
    49. public boolean equals(Object obj) {
    50. if(obj instanceof SortAPI){
    51. SortAPI o = (SortAPI)obj;
    52. return this.first == o.first && this.second == o.second;
    53. }
    54. return false;
    55. }
    56. @Override
    57. public String toString() {
    58. return 'first:' + this.first + 'second:' + this.second;
    59. }
    60. }

    这类型重写compareTo(SortAPI o)、write(DataOutput out)、readFields(DataInput in)，既然是有比较那么以前说的就一定要重写hashCode()、equals(Object obj)方法了，这点不要忘记！还需要主要在write方法以及readFields方法中读写是有顺序：先write什么字段就先read什么字段。其次这个compareTo(SortAPI o)方法中返回是整型大于0、0、以及小于0代表大于、等于、小于。至于怎么判断2行数据是不是相等，不相等怎么比较着逻辑可以慢慢看下。

    下面写个自定义Mapper、Reducer类以及main函数：

    01. public class MyMapper extends Mapper<LongWritable, Text, SortAPI, LongWritable> {
    02.  
    03. @Override
    04. protected void map(LongWritable key, Text value,Context context) throws IOException, InterruptedException {
    05. String[] splied = value.toString().split('  ');
    06. try {
    07. long first = Long.parseLong(splied[0]);
    08. long second = Long.parseLong(splied[1]);
    09. context.write(new SortAPI(first,second), new LongWritable(1));
    10. } catch (Exception e) {
    11. System.out.println(e.getMessage());
    12. }
    13. }
    14. }
    1. public class MyReduce extends Reducer<SortAPI, LongWritable, LongWritable, LongWritable> {
    2.  
    3. @Override
    4. protected void reduce(SortAPI key, Iterable<LongWritable> values, Context context)throws IOException, InterruptedException {
    5. context.write(new LongWritable(key.first), new LongWritable(key.second));
    6. }
    7.  
    8. }
    01. static final String OUTPUT_DIR = 'hdfs://hadoop-master:9000/sort/output/';
    02. static final String INPUT_DIR = 'hdfs://hadoop-master:9000/sort/input/test.txt';
    03.  
    04. public static void main(String[] args) throws Exception {
    05. Configuration conf = new Configuration();
    06. Job job = new Job(conf, Test.class.getSimpleName());       
    07. deleteOutputFile(OUTPUT_DIR);
    08.  
    09. //1设置输入目录
    10. FileInputFormat.setInputPaths(job, INPUT_DIR);
    11. //2设置输入格式化类
    12. job.setInputFormatClass(TextInputFormat.class);
    13. //3设置自定义Mapper以及键值类型
    14. job.setMapperClass(MyMapper.class);
    15. job.setMapOutputKeyClass(SortAPI.class);
    16. job.setMapOutputValueClass(LongWritable.class);
    17. //4分区
    18. job.setPartitionerClass(HashPartitioner.class);
    19. job.setNumReduceTasks(1);
    20.  
    21. //5排序分组
    22. //6设置在一定Reduce以及键值类型
    23. job.setReducerClass(MyReduce.class);
    24. job.setOutputKeyClass(LongWritable.class);
    25. job.setOutputValueClass(LongWritable.class);
    26. //7设置输出目录
    27. FileOutputFormat.setOutputPath(job, new Path(OUTPUT_DIR));
    28. //8提交job
    29. job.waitForCompletion(true);
    30. }
    31.  
    32. static void deleteOutputFile(String path) throws Exception{
    33. Configuration conf = new Configuration();
    34. FileSystem fs = FileSystem.get(new URI(INPUT_DIR),conf);
    35. if(fs.exists(new Path(path))){
    36. fs.delete(new Path(path));
    37. }
    38. }

    这样在eclipse下就可以直接运行查看结果：

    1. 1       1
    2. 1       2
    3. 2       2
    4. 3       0
    5. 3       2

    这结果正确，那如果要求第一列倒叙第二列升序呢，怎么办，这只需要修改下compareTo(SortAPI o)：

    01. @Override
    02. public int compareTo(SortAPI o) {
    03. long mis = (this.first - o.first) * -1 ;
    04. if(mis != 0 ){
    05. return (int)mis;
    06. }
    07. else{
    08. return (int)(this.second - o.second);
    09. }
    10. }

    这样保存在运行，结果：

    1. 3       0
    2. 3       2
    3. 2       2
    4. 1       1
    5. 1       2

    也正确吧符合自己的这个要求。

    留个小问题：这个compareTo(SortAPI o)方法在什么时候调用了，总共调用了几次？

    这次先到这里。坚持记录点点滴滴！

冥想者-定
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
hadoop二次排序的原理和实现方法
10-16
二次排序在Hadoop中主要涉及Map、Reduce阶段以及自定义类的实现。 1. 二次排序原理： - Map阶段：Map任务接收输入数据，将其切分为多个Split，由InputFormat的RecordReader将数据读取并转化为键值对（通常是, Text...
Mapreduce_WritableComparable自定义示例
Binder~的博客
11-13 477
通过override compareTo（）方法来实现自定义排序规则 代码如下：package com.xfyan.MR.one; import java.io.DataInput; import java.io.DataOutput; import java.io.IOException; import org.apache.hadoop.io.Text; import org.apach
Hadoop中的MapReduce框架原理、WritableComparable排序案例实操（区内排序）、Combiner合并、自定义 Combiner 实现步骤
Redamancy06的博客
10-05 362
Combiner是MR程序中Mapper和Reducer之外的一种组件、Combiner组件的父类就是Reducer、Combiner和Reducer的区别在于运行的位置，Combiner是在每一个MapTask所在的节点运行，Reducer是接收全局所有Mapper的输出结果、Combiner的意义就是对每一个MapTask的输出进行局部汇总，以减小网络传输量、Combiner能够应用的前提是不能影响最终的业务逻辑，而且，Combiner的输出kv应该跟Reducer的输入kv类型要对应起来、自定义一个
Hadoop中的MapReduce框架原理、WritableComparable排序案例实操（区内排序）、Combiner合并、自定义 Combiner 实现步骤_自定义combiner案例(6)
最新发布
2401_84181286的博客
04-30 217
\*\*\*/@Override//获取手机号前三位prePhone//定义一个分区号变量partition, 根据prePhone 设置分区号}else {//最后返回分区号partition/\*\*\*/@Override。
Hadoop框架之——Mapreduce WritableComparable 排序
weixin_45417821的博客
08-07 236
概述 排序是MapReduce框架中最重要的操作之一。 MapTask和ReduceTask均会对数据按照key进行排序。该操作属于Hadoop的默认行为。任何应用程序中的数据均会被排序，而不管逻辑上是.否需要。 默认排序是按照字典顺序排序，且实现该排序的方法是快速排序。 对于MapTask,它会将处理的结果暂时放到环形缓冲区中，当环形缓冲区使用率达到一定阈值后，再对缓冲区中的数据进行一-次快速排序,并将这些有序数据溢写到磁盘上,而当数据处理完毕后，它会对磁盘上所有文件进行归并排序。 对于ReduceTas
Hadoop案例：WritableComparable实现分区内排序
小M呀~之大数据系列
12-03 1625
排序是maprduce的重要部分，这里将利用继承WritableComparable实现自定义排序。
MapReduce自定义排序WriteComparable
weixin_46429290的博客
07-22 801
MapReduce自定义排序 MapReduce会按数据的Key进行默认的排序，如果想要进行定制排序，可以实现WritableComparable接口，重写compareTo方法 注意，以上的办法是作用于MapReduce阶段的Key值进行排序，如果要对Value进行排序，则这里的写法不会起作用，按照Value的排序，在下面给出 实现WritableComparable接口之后需要实现三个方法，分别是序列化方法，反序列化方法和compareTo方法 需求，按照时间戳的正序进行排序 要求在AISDataBea
Hadoop大作业排序.zip
07-02
Hadoop大作业排序代码 由于 MapReduce 中对 key 进行比较和排序，而 key 可以是任何实 现了 Writable 接口的类。 在 java 中，要实现类的大小比较可以实现 Comparable 接口并通 过重写 compareTo 方法来实现。 在 ...
hadoop自定义类型编程
04-29
如果自定义类型还需要作为排序的键（Key），则应实现`org.apache.hadoop.io.WritableComparable<T>`接口。这会额外要求你实现`compareTo(T other)`方法，以定义比较规则。确保此方法的实现符合你的业务需求，例如，...
hadoop MapReduce实例解析
06-15
MapReduce还提供了一些特别的数据类型，例如BooleanWritable、ByteWritable等，这些数据类型都实现了WritableComparable接口，以便用这些类型定义的数据可以被序列化进行网络传输和文件存储，以及进行大小比较。...
Hadoop中MapReduce基本案例及代码（四）
01-07
如果想将mapreduce结果排序，需将排序对象作为键值。 案例：将利润求和后按照顺序排序 数据源 profit.txt 编号 | 姓名 | 收入 | 支出 1 ls 2850 100 2 ls 3566 200 3 ls 4555 323 1 zs 19000 2000 2 zs 28599 3900 3...
MapReduce2中自定义排序分组
08-12
NULL 博文链接：https://username2.iteye.com/blog/2274802
mapreduce wc单词计数 自定义分区 自定义排序实现
09-07
实现mr的wordcount功能和自定义分区的功能、自定义排序功能；com.ellis.mr1为类似wc功能，com.ellis.mr2为自定义分区功能，com.ellis.mr3为自定义排序功能
数据分析—排序
白墨的小白博客
12-04 952
排序是数据分析中最常用的操作，没有之一。 单字段升序： 利用 mapreduce 自身的排序机制，把需要排序的字段作为 key 即可 其它排序： 自定义排序规则 方案一：自定义 key 1. 自定义类实现 WritableComparable 接口，设置泛型为自定义类 2. 声明需要排序的字段，添加 setter &amp;&amp; getter ...
MapReduce实战小案例（自定义排序、二次排序、分组、分区）
fengxiandada的博客
06-26 6922
MapReduce实战小案例
mapreduce的自定义排序
qq_27347421的博客
01-28 1131
默认排序： map ------shuffle(排序–>分组)-----reduce 在shuffle过程中，先按照map输出的key进行排序。 如果key是数值类型，按大小排序 如果key是字符串类型，按照字典顺序升序排 在按照map输出的key进行分组 运用shuffle过程中的排序： 想要运用shffle过程中的排序，则排序字段为map输出的key。 自定义排序----二次排...
mapreduce
KZZ‘s PDG的博客
07-27 310
Hadoop-Mapreduce 1. MapReduce 介绍 MapReduce思想在生活中处处可见。或多或少都曾接触过这种思想。MapReduce的思想核心是“分而治之”，适用于大量复杂的任务处理场景（大规模数据处理场景）。 Map负责“分”，即把复杂的任务分解为若干个“简单的任务”来并行处理。可以进行拆分的前提是这些小任务可以并行计算，彼此间几乎没有依赖关系。 Reduce负责“合”，即...
第八章 MapReduce流量统计项目的案例详解之自定义排序
weixin_51524477的博客
11-20 286
自定义排序
mapreduce linux实例,Hadoop之MapReduce自定义二次排序流程实例详解
05-24
自定义二次排序是MapReduce中常见的一种需求，其目的是对MapReduce的输出进行排序。下面我们来介绍一下如何在Linux上使用Hadoop实现自定义二次排序。 1. 准备数据 首先我们需要准备一个数据集，假设我们有一个文本...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值