MapReduce-TopK

最新推荐文章于 2024-05-06 18:24:51 发布
最新推荐文章于 2024-05-06 18:24:51 发布
阅读量650 收藏 2
点赞数
分类专栏： hadoop MapReduce 文章标签： hadoop MapReduce

友情提示：更多有关大数据、人工智能方面技术文章请关注博主个人微信公众号：高级大数据架构师！

上一篇博客中简单的写了一个MapReduce的程序，其中只重写了map()和reduce()方法，但里面还有cleanup(Context context)，
setup(Context context）和run(Context context)方法可以可以重写
这一个实例，我们就说明一下cleanup(Context context)，setup(Context context）这两个方法的作用以及在本例中的用法，
以及TopK的MapReduce的写法，对于TopK这里将根据实际情况用种方法来实现，一种是只关注TopK的数值，另一种情况是不但

 

关心TopK的数值，而且还要输出TopK的相关信息

 

首先讲解setup(Context context）和cleanup(Context context)的作用
以下是hadoop1.2.1中截取换源码，位于org.apache.hadoop.mapreduce.Mapper类中

 

[java] view plain copy

  1. /** 
  2.    * Called once at the beginning of the task. 
  3.    */  
  4.   protected void setup(Context context ) throws IOException, InterruptedException {  
  5.     // NOTHING  
  6.   }  
  7.   /** 
  8.    * Called once at the end of the task. 
  9.    */  
  10.   protected void cleanup(Context context ) throws IOException, InterruptedException {  
  11.     // NOTHING  
  12.   }  

由注释可知道setup()方法是在任务开始之前调用一次，cleanup()方法则是在任务结束之后调用一次
所以这两个方法可以用来对初始的变量进行赋值，或文件的分发，以及任务执行完成过后对资源的释放
在本例中我们会用这两个方法来做TopK中K值的指定。在以后的博客中我们还会有其它的用法。


以下的代码是Mapper类中的一个重要的方法，从run()可以看到任务提交后首先执行setup(context)方法
然后通过判断是否还有下一个值，不停的调用map()方法，最后在调用cleanup(context)方法，这就是一Map执行的顺序
这里不详细讲解nextKeyValue()方法，后面在讲解RecordReader的定制的博客中会做详细的讲解，参见MapReduce-xml文件的处理-定制InputFormat及定制RecordReader。

 

 

[java] view plain copy

  1. /** 
  2.   * Expert users can override this method for more complete control over the 
  3.   * execution of the Mapper. 
  4.   * @param context 
  5.   * @throws IOException 
  6.   */  
  7.  public void run(Context context) throws IOException, InterruptedException {  
  8.    setup(context);  
  9.    try {  
  10.     //map通过这里反复调用RecordReader的方法  
  11.     while (context.nextKeyValue()) {  
  12.     //context.getCurrentKey()在MapContext的方法中调用相关RecordReader的方法  
  13.         /** 
  14.          * @Override 
  15.          *      public KEYIN getCurrentKey() throws IOException, InterruptedException { 
  16.          *          return reader.getCurrentKey(); 
  17.          *      } 
  18.          */  
  19.        map(context.getCurrentKey(), context.getCurrentValue(), context);  
  20.      }  
  21.    } finally {  
  22.      cleanup(context);  
  23.    }  
  24.  }  

接下来我们开始写TopK的第一个情况的程序
测试数据：
uid,name,cost
1,mr1,3234
2,mr2,123
3,mr3,9877
4,mr4,348
5,mr5,12345
6,mr6,6646
7,mr7,98
8,mr8,12345
现在要提取出消费最高的金额前3的是多少
map阶段：

 

[java] view plain copy

  1. import java.io.IOException;  
  2. import java.util.Arrays;  
  3. import org.apache.hadoop.io.IntWritable;  
  4. import org.apache.hadoop.io.LongWritable;  
  5. import org.apache.hadoop.io.Text;  
  6. import org.apache.hadoop.mapreduce.Mapper;  
  7.   
  8. public class TopKMapper extends Mapper<LongWritable, Text, IntWritable, IntWritable> {  
  9.       
  10.     int len;  
  11.     int[] tmp;  
  12.   
  13.     /** 
  14.      * Map任务启动的时候调用 
  15.      */  
  16.     @Override  
  17.     protected void setup( Context context)  
  18.             throws IOException, InterruptedException {  
  19.         /** 
  20.          * 通过context获取任务启动时传入的TopK的K值 
  21.          */  
  22.         len = context.getConfiguration().getInt("K", 10);  
  23.         /** 
  24.          * 创建一个数组来存放topK的值 
  25.          */  
  26.         tmp = new int[len + 1];  
  27.     }  
  28.   
  29.     @Override  
  30.     protected void map(LongWritable key, Text value, Context context)  
  31.             throws IOException, InterruptedException {  
  32.         String line = value.toString();  
  33.         String[] arr = line.split(",");  
  34.         if(arr.length == 3) {  
  35.             addParm(Integer.valueOf(arr[2]));  
  36.         }  
  37.     }  
  38.     /** 
  39.      * 把新取出的数值放到数组中的第一位，并按从小到大排序 
  40.      * 这样下一次放入时就把最小的数值去除掉了 
  41.      */  
  42.     private void addParm(int parm) {  
  43.         tmp[0] = parm;  
  44.         Arrays.sort(tmp);  
  45.     }  
  46.       
  47.     @Override  
  48.     protected void cleanup(Context context)  
  49.             throws IOException, InterruptedException {  
  50.         /** 
  51.          * 把数组中的数值倒序的输出，这样每个Map就输出了自己的TOPK去reduce端 
  52.          */  
  53.         for( int i = 1 ; i <= len ; i ++) {  
  54.             context.write(new IntWritable(tmp[i]), new IntWritable(tmp[i]));  
  55.         }  
  56.     }  
  57. }  

reduce阶段：

 

 

[java] view plain copy

  1. import java.io.IOException;  
  2. import java.util.Arrays;  
  3. import org.apache.hadoop.io.IntWritable;  
  4. import org.apache.hadoop.mapreduce.Reducer;  
  5.   
  6. public class TopKReducer extends Reducer<IntWritable, IntWritable, IntWritable, IntWritable> {  
  7.     int len;  
  8.     int[] tmp;  
  9.       
  10.     @Override  
  11.     protected void setup( Context context)  
  12.             throws IOException, InterruptedException {  
  13.         len = context.getConfiguration().getInt("K", 10);  
  14.         tmp = new int[len + 1];  
  15.     }  
  16.   
  17.     @Override  
  18.     protected void reduce(IntWritable key, Iterable<IntWritable> values, Context arg2)  
  19.             throws IOException, InterruptedException {  
  20.         for(IntWritable value: values) {  
  21.             addParm(value.get());  
  22.         }  
  23.     }  
  24.   
  25.     private void addParm(int parm) {  
  26.         tmp[0] = parm;  
  27.         Arrays.sort(tmp);  
  28.     }  
  29.       
  30.     @Override  
  31.     protected void cleanup( Context context)  
  32.             throws IOException, InterruptedException {  
  33.         for( int i = len; i > 0 ; i --) {  
  34.             context.write(new IntWritable(len - i + 1), new IntWritable(tmp[i]));  
  35.         }  
  36.     }  
  37. }  

启动函数：

 

 

[java] view plain copy

  1. import org.apache.hadoop.conf.Configuration;  
  2. import org.apache.hadoop.fs.FileSystem;  
  3. import org.apache.hadoop.fs.Path;  
  4. import org.apache.hadoop.io.IntWritable;  
  5. import org.apache.hadoop.mapreduce.Job;  
  6. import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;  
  7. import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;  
  8.   
  9. public class JobMain {  
  10.     public static void main(String[] args) throws Exception {  
  11.         Configuration configuration = new Configuration();  
  12.         /** 
  13.          * 把传入参数放入Configuration中，map或reduce中可以通过 
  14.          * 获取Configuration来获取传入的参数，这是hadoop传入参数的 
  15.          * 方式之一 
  16.          */  
  17.         configuration.set("K", args[2]);  
  18.         Job job = new Job(configuration, "topK-job");  
  19.         job.setJarByClass(JobMain.class);  
  20.         job.setMapperClass(TopKMapper.class);  
  21.         job.setMapOutputKeyClass(IntWritable.class);  
  22.         job.setMapOutputValueClass(IntWritable.class);  
  23.         job.setReducerClass(TopKReducer.class);  
  24.         job.setOutputKeyClass(IntWritable.class);  
  25.         job.setOutputValueClass(IntWritable.class);  
  26.         FileInputFormat.addInputPath(job, new Path(args[0]));  
  27.         Path outputDir = new Path(args[1]);  
  28.         FileSystem fs = FileSystem.get(configuration);  
  29.         if(fs.exists(outputDir)) {  
  30.             fs.delete(outputDir, true);  
  31.         }  
  32.         FileOutputFormat.setOutputPath(job, outputDir);  
  33.         System.exit(job.waitForCompletion(true)? 0: 1);  
  34.     }  
  35. }  

 

 

测试结果：

 

 

 

测试数据：
uid,name,cost
1,mr1,3234
2,mr2,123
3,mr3,9877
4,mr4,348
5,mr5,12345
6,mr6,6646
7,mr7,98
8,mr8,12345
现在要提取出消费最高的金额前3的name加金额

map阶段：

 

[java] view plain copy

  1. import java.io.IOException;  
  2. import java.util.Map.Entry;  
  3. import java.util.Comparator;  
  4. import java.util.Set;  
  5. import java.util.TreeMap;  
  6. import org.apache.hadoop.io.IntWritable;  
  7. import org.apache.hadoop.io.LongWritable;  
  8. import org.apache.hadoop.io.Text;  
  9. import org.apache.hadoop.mapreduce.Mapper;  
  10.   
  11. public class TopKTreeMapper extends  
  12.         Mapper<LongWritable, Text, IntWritable, Text> {  
  13.   
  14.     private int len;  
  15.     private TreeMap<Integer, String> tmp;  
  16.     private IntWritable key = new IntWritable();  
  17.     private Text value = new Text();  
  18.     /** 
  19.      * Map任务启动的时候调用 
  20.      */  
  21.     @Override  
  22.     protected void setup(Context context) throws IOException,  
  23.             InterruptedException {  
  24.         /** 
  25.          * 通过context获取任务启动时传入的TopK的K值 
  26.          */  
  27.         len = context.getConfiguration().getInt("K", 10);  
  28.         tmp = new TreeMap<Integer, String>(new Comparator<Integer>() {  
  29.   
  30.             @Override  
  31.             public int compare(Integer o1, Integer o2) {  
  32.                 return o2-o1;  
  33.             }  
  34.         });  
  35.     }  
  36.   
  37.     @Override  
  38.     protected void map(LongWritable key, Text value, Context context)  
  39.             throws IOException, InterruptedException {  
  40.         String line = value.toString();  
  41.         String[] arr = line.split(",");  
  42.         if (arr.length == 3) {  
  43.             addParm(Integer.valueOf(arr[2]), arr[1]);  
  44.         }  
  45.     }  
  46.   
  47.     /** 
  48.      * 把新取出的数值放到数组中的第一位，并按从小到大排序 这样下一次放入时就把最小的数值去除掉了 
  49.      */  
  50.     private void addParm(int parm, String name) {  
  51.         tmp.put(parm, name);  
  52.         if (tmp.size() > len) {  
  53.             tmp.remove(tmp.lastKey());  
  54.         }  
  55.     }  
  56.   
  57.     @Override  
  58.     protected void cleanup(Context context) throws IOException,  
  59.             InterruptedException {  
  60.         Set<Entry<Integer, String>> set = tmp.entrySet();  
  61.         for (Entry<Integer, String> entry : set) {  
  62.             key.set(entry.getKey());  
  63.             value.set(entry.getValue());  
  64.             context.write(key, value);  
  65.         }  
  66.     }  
  67. }  

reduce阶段：

 

 

[java] view plain copy

  1. import java.io.IOException;  
  2. import java.util.Map.Entry;  
  3. import java.util.Comparator;  
  4. import java.util.Set;  
  5. import java.util.TreeMap;  
  6. import org.apache.hadoop.io.IntWritable;  
  7. import org.apache.hadoop.io.Text;  
  8. import org.apache.hadoop.mapreduce.Reducer;  
  9.   
  10. public class TopKTreeReducer extends Reducer<IntWritable, Text, Text, IntWritable> {  
  11.     int len;  
  12.     private TreeMap<Integer, String> tmp;  
  13.     private IntWritable key = new IntWritable();  
  14.     private Text value = new Text();  
  15.       
  16.     @Override  
  17.     protected void setup( Context context)  
  18.             throws IOException, InterruptedException {  
  19.         len = context.getConfiguration().getInt("K", 10);  
  20.         tmp = new TreeMap<Integer, String>(new Comparator<Integer>() {  
  21.             @Override  
  22.             public int compare(Integer o1, Integer o2) {  
  23.                 return o2-o1;  
  24.             }  
  25.         });  
  26.     }  
  27.   
  28.     @Override  
  29.     protected void reduce(IntWritable key, Iterable<Text> values, Context arg2)  
  30.             throws IOException, InterruptedException {  
  31.         for(Text value : values) {  
  32.             addParm(key.get(), value.toString());  
  33.         }  
  34.     }  
  35.   
  36.     private void addParm(int parm, String name) {  
  37.         tmp.put(parm, name);  
  38.         if (tmp.size() > len) {  
  39.             tmp.remove(tmp.lastKey());  
  40.         }  
  41.     }  
  42.       
  43.     @Override  
  44.     protected void cleanup( Context context)  
  45.             throws IOException, InterruptedException {  
  46.         Set<Entry<Integer, String>> set = tmp.entrySet();  
  47.         for (Entry<Integer, String> entry : set) {  
  48.             key.set(entry.getKey());  
  49.             value.set(entry.getValue());  
  50.             context.write(value, key);  
  51.         }  
  52.     }  
  53. }  

启动函数：

 

 

[java] view plain copy

  1. import org.apache.hadoop.conf.Configuration;  
  2. import org.apache.hadoop.fs.FileSystem;  
  3. import org.apache.hadoop.fs.Path;  
  4. import org.apache.hadoop.io.IntWritable;  
  5. import org.apache.hadoop.io.Text;  
  6. import org.apache.hadoop.mapreduce.Job;  
  7. import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;  
  8. import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;  
  9.   
  10. public class JobMainTree {  
  11.     public static void main(String[] args) throws Exception {  
  12.         Configuration configuration = new Configuration();  
  13.         /** 
  14.          * 把传入参数放入Configuration中，map或reduce中可以通过 
  15.          * 获取Configuration来获取传入的参数，这是hadoop传入参数的 
  16.          * 方式之一 
  17.          */  
  18.         configuration.set("K", args[2]);  
  19.         Job job = new Job(configuration, "topK-job-tree");  
  20.         job.setJarByClass(JobMainTree.class);  
  21.         job.setMapperClass(TopKTreeMapper.class);  
  22.         job.setMapOutputKeyClass(IntWritable.class);  
  23.         job.setMapOutputValueClass(Text.class);  
  24.         job.setReducerClass(TopKTreeReducer.class);  
  25.         job.setOutputKeyClass(Text.class);  
  26.         job.setOutputValueClass(IntWritable.class);  
  27.         FileInputFormat.addInputPath(job, new Path(args[0]));  
  28.         Path outputDir = new Path(args[1]);  
  29.         FileSystem fs = FileSystem.get(configuration);  
  30.         if(fs.exists(outputDir)) {  
  31.             fs.delete(outputDir, true);  
  32.         }  
  33.         FileOutputFormat.setOutputPath(job, outputDir);  
  34.         System.exit(job.waitForCompletion(true)? 0: 1);  
  35.     }  
  36. }  

运行结果：

 



结论：如果仔细观察结果会发现，第二次运行结果没有重复的最大值出现，重复的值只出现了一次而且是最新进入TreeMap的值，这是因为TreeMap的属性的问题，这里我们不做过多的讨论，这篇博客只是熟悉Mapper类中可重写方法的用途。下一篇博客讲解自定义输入类型，并解决这一篇遗留的即要取name字段又要取cost字段，但还要保留做重复金额的问题。

MapReduce TopK问题实际应用
lavimer
01-28 4282
一：背景 TopK问题应该是海量数据处理中应用最广泛的了，比如在海量日志数据处理中，对数据清洗完成之后统计某日访问网站次数最多的前K个IP。这个问题的实现方式并不难，我们完全可以利用MapReduce的Shuffle过程实现排序，然后在Reduce端进行简单的个数判断输出即可。这里还涉及到二次排序，不懂的同学可以参考我之前的文章。 二：技术实现 #我们先来看看一条Ngnix服务器的日
MapReduce---TopN
XiaodunLP的博客
02-14 239
package com.mapreduce.topn; import org.apache.hadoop.io.Text; public class Item implements Comparable&lt;Item&gt;{ private Long count; private String content; public Item() { } ...
Mapreduce实例-TopK
897371388
09-05 185
public class TopK extends Configured implements Tool { public static class TopKMapper extends Mapper&lt;Object, Text, NullWritable, LongWritable&gt; { public static final int K = 100...
hadoop mapreduce 解决 top K问题
weixin_30907935的博客
12-04 297
网上搜索到的那个top K问题的解法，我觉得有些地方都没有讲明白。因为我们要找出top K, 那么就应该显式的指明the num of reduce tasks is one. 不然我还真不好理解为什么可以得到top K的结果。这里顺便提及一下，一个map task就是一个进程。有几个map task就有几个中间文件，有几个reduce task就有几个最终输出文件。好了，这就好理解了，我们要...
MapReduce - topk
PeersLee的博客
10-05 520
package topk; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.fs.Path; import org.apache.hadoop.io.LongWritable; import org.apache.hadoop.io.Text; import org.apache.hadoop.mapr...
MapReduce实现TopK算法（实战）
围炉夜敲的博客
10-24 3356
MapReduce实现TopK算法（实战） 项目介绍 数据集下载 程序下载 代码讲解 运行结果示例
【MapReduce】扩展案例 ---- TopN（求取数据集前N名）_topn maprreduce
最新发布
2301_76379606的博客
05-06 514
定义在map()外面。
MapReduce中高效的Top-k天际线计算
03-12
在本文中，作者提出了一个分布式Top-k天际线计算方法，命名为MR-DTKS（MapReduce Distributive Top-k Skyline）。该方法首先将多维数据转换为单个值以确定两个数据点之间的支配关系，接着利用转换值来计算分数，过滤...
MapReduce Top-K问题
Li_and_Li的博客
09-09 551
Mappers 使用默认的mapper数据，一个input split（输入分片）由一个mapper来处理。 在每一个map task中，我们找到这个input split的前k个记录。这里我们用TreeMap这个数据结构来保存top K的数据，这样便于更新。下一步，我们来加入新记录到TreeMap中去（这里的TreeMap我感觉就是个大顶堆）。在map中，我们对每一条记录都尝试去更新Tree...
mapreduce Top K算法
梁小明的博客
12-27 1461
Hadoop topK 算法 非常重要的！！！面试一定考到的！！！哈哈哈
利用MapReduce解决在海量数据中求Top K个数<转>
yongjian_luo的专栏
03-24 977
利用MapReduce求海量数据中最大的K个数   [java] view plaincopy package jtlyuan.csdn;   import java.io.IOException;   import org.apache.hadoop.conf.Configuration;   import org.apache
TopK问题--MapReduce处理
qq_28027543的博客
12-23 196
原始数据 分为8个block存储，847 MB 数据格式：每个数字是[0,1亿）区域内的随机数(存储的byte长度也不一样，比如：随机数1只用一个byte存储字符1 ; 随机数200 则需要3个字符存储)，之间用空格分开。 InputFormat设置 根据数据格式设计分割方式：根据cpu最多并行12线程，应该分割为12个split，开启12个mapTask同时读数据。每条record之...
hadoop-MapReduce 实现TopK的方法
Chain的博客
07-08 806
（1）本文的目的是对搜狗的用户查询日志的利用sum进行排序，选出搜索比较热的一些查询，语料集如下： 列名分别为 访问时间\t用户ID\t[查询词]\t该URL在返回结果中的排名\t用户点击的顺序号\t用户点击的URL （2）这里实现分为了三种方式去实现 （2.1）第一种，利用TreeMap与重写cleanUp进行实现，个人觉得这是最简单的一种方法了，但是它有一定的缺点，缺点在后面会提到，...
MapReduce实现TopK
龙崎的专栏
03-23 3375
Hadoop inaction上面的练习。 刚开始考虑，每个分片应该是在所有的记录处理完之后，把这个分片的前K大输出给reduce，但是map函数是每个记录调用一遍，把怎么在所有记录调用完之后处理呢？ setup()，此方法被MapReduce框架仅且执行一次，在执行Map任务前，进行相关变量或者资源的集中初始化工作。若是将资源初始化工作放在方法map()中，导致Mapper任务在解析每一
Hadoop读书笔记（十四）MapReduce中TopK算法（Top100算法）
caicongyang
12-11 5190
Hadoop1.x中MapReduce中TopK算法（Top100算法）
MapReduceTopK TreeMap
潇洒子弦
06-22 2193
MapReduce TopK统计加排序中介绍的TopK在mapreduce的实现。 本案例省略的上面案例中的Sort步骤，改用TreeMap来实现获取前K个词 package TopK1; import java.io.IOException; import java.util.StringTokenizer; import org.apache.hadoop.conf.Configurat
基于MapReduce的TOP-K查询问题的实现
believe_stone的博客
01-15 3506
TreeMap存储前K个数据 如何存储前K个数据是TopK问题的一大核心问题，这里采用Java中TreeMap来进行存储。TreeMap的实现是红黑树算法的实现，红黑树又称红-黑二叉树，它首先是一棵二叉树，它具体二叉树所有的特性，同时红黑树更是一棵自平衡的排序二叉树。平衡二叉树必须具备如下特性：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。也就是说该
MapReduce统计服务器日志TopK数据分析
本资源包提供了一个TopK-Log-Map-Reduce-master的项目实例，该项目包含MapReduce程序的全部代码，用于处理服务器日志数据，并从中提取出访问频率最高的top k数据项。" 详细知识点如下： 1. MapReduce方法介绍 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值