如何使用Hadoop的Reduce Side Join

最新推荐文章于 2023-03-02 14:25:10 发布
最新推荐文章于 2023-03-02 14:25:10 发布
阅读量169 收藏
点赞数
分类专栏： Hadoop 文章标签： mapreduce hadoop reduce join
[b][color=green][size=large]我们都知道在数据库里，多个表之间是可以根据某个链接键进行join的，这也是数据库的范式规范，通过主外键的关联，由此来减少数据冗余，提高性能。当然近几年，随着NOSQL的兴起，出现了基于列的的列式数据库，典型的有Hbase，MongonDB，Cassdran，等等，NOSQL数据库弱化了关联，直接将一整条数据，存入一列，以及去掉了数据库的部分事务特性，从而在海量数据面前显得游刃有余，当然，大部分的NOSQL不支持join操作，也没有绝对的必要支持，因为现在，我们完全是把一整条数据存在了一起，虽然多了许多冗余，但也换来了比较高检索性能，扩展性能，可靠性能。但某些业务场景下，我们仍然需要Join操作，这时候怎么办？

如果数据量比较大的情况下，我们可以使用Hadoop的MapReduce来完成大表join，尤其对Hbase的某些表进行join操作，当然我们也可以使用Hive或Pig来完成，其实质在后台还是运行的一个MR程序。

那么，散仙今天就来看下如何使用MapReduce来完成一个join操作，Hadoop的join分为很多种例如；Reduce链接，Map侧链接，半链接和Reduce侧链接+BloomFilter等等，各个链接都有自己特定的应用场景，没有绝对的谁好谁坏。


今天散仙要说的是，基于Reduce侧的链接，原理如下：
1、在Reudce端进行连接。
在Reudce端进行连接是MapReduce框架进行表之间join操作最为常见的模式，其具体的实现原理如下：
Map端的主要工作：为来自不同表（文件）的key/value对打标签以区别不同来源的记录。然后用连接字段作为key，其余部分和新加的标志作为value，最后进行输出。
reduce端的主要工作：在reduce端以连接字段作为key的分组已经完成，我们只需要在每一个分组当中将那些来源于不同文件的记录（在map阶段已经打标志）分开，最后进行笛卡尔只就ok了。

本次的实现是基于hadoop的旧版API+contribu扩展包里的，DataJoin的工具类辅助来完成的，下篇博客，将会给出，基于新版API，独立来完成Reduce侧的连接示例。
[/size][/color][/b]
[b][color=olive][size=large]现在看下散仙的两个文件的测试数据，一个是a.txt，另一个是b.txt[/size][/color][/b] 

a文件的数据

1,三劫散仙,13575468248
2,凤舞九天,18965235874
3,忙忙碌碌,15986854789
4,少林寺方丈,15698745862




b文件的数据

3,A,99,2013-03-05
1,B,89,2013-02-05
2,C,69,2013-03-09
3,D,56,2013-06-07


[b][color=olive][size=large]源码如下：[/size][/color][/b] 
package com.qin.reducejoin;


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

import org.apache.hadoop.conf.Configuration;  
import org.apache.hadoop.conf.Configured;  
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;  
import org.apache.hadoop.io.Text;  
import org.apache.hadoop.io.Writable;  
import org.apache.hadoop.mapred.FileInputFormat;  
import org.apache.hadoop.mapred.FileOutputFormat;  
import org.apache.hadoop.mapred.JobClient;  
import org.apache.hadoop.mapred.JobConf;  
import org.apache.hadoop.mapred.KeyValueTextInputFormat;  
import org.apache.hadoop.mapred.MapReduceBase;  
import org.apache.hadoop.mapred.Mapper;  
import org.apache.hadoop.mapred.OutputCollector;  
import org.apache.hadoop.mapred.Reducer;  
import org.apache.hadoop.mapred.Reporter;  
import org.apache.hadoop.mapred.TextInputFormat;  
import org.apache.hadoop.mapred.TextOutputFormat;  
import org.apache.hadoop.util.ReflectionUtils;
import org.apache.hadoop.util.Tool;  
import org.apache.hadoop.util.ToolRunner;  

import org.apache.hadoop.contrib.utils.join.DataJoinMapperBase;  
import org.apache.hadoop.contrib.utils.join.DataJoinReducerBase;  
import org.apache.hadoop.contrib.utils.join.TaggedMapOutput;  

import com.qin.joinreduceerror.JoinReduce;


/***
 * 
 * Hadoop1.2的版本，旧版本实现的Reduce侧连接
 * 
 * @author qindongliang
 * 
 *    大数据交流群：376932160
 *  搜索技术交流群：324714439
 * 
 * 
 */

public class DataJoin extends Configured implements Tool {  


	/**
	 * 
	 * Map实现
	 * 
	 * */
    public static class MapClass extends DataJoinMapperBase {  

    	/**
    	 * 读取输入的文件路径
    	 * 
    	 * **/
        protected Text generateInputTag(String inputFile) {  

        	//返回文件路径，做标记
            return new Text(inputFile);  
        }  


        /***
         * 分组的Key
         * 
         * **/

        protected Text generateGroupKey(TaggedMapOutput aRecord) {  
            String line = ((Text) aRecord.getData()).toString();  
            String[] tokens = line.split(",");  
            String groupKey = tokens[0];  
            return new Text(groupKey);  
        }  




        protected TaggedMapOutput generateTaggedMapOutput(Object value) {  
            TaggedWritable retv = new TaggedWritable((Text) value);  
            retv.setTag(this.inputTag);  
            return retv;  
        }  
    }  

    /**
     * 
     * Reduce进行笛卡尔积
     * 
     * **/
    public static class Reduce extends DataJoinReducerBase {  


    	/***
    	 * 笛卡尔积
    	 * 
    	 * */
        protected TaggedMapOutput combine(Object[] tags, Object[] values) {  
            if (tags.length < 2) return null;    
            String joinedStr = "";   
            for (int i=0; i<values.length; i++) {  
                if (i > 0) {joinedStr += ",";}  
                TaggedWritable tw = (TaggedWritable) values[i];  
                String line = ((Text) tw.getData()).toString();  
                String[] tokens = line.split(",", 2);  
                joinedStr += tokens[1];  
            }  
            TaggedWritable retv = new TaggedWritable(new Text(joinedStr));  
            retv.setTag((Text) tags[0]);   
            return retv;  
        }  
    }  

    /**
     * 
     * 自定义的输出类型
     * 
     * ***/
    public static class TaggedWritable extends TaggedMapOutput {  

        private Writable data;  

        /**
         * 注意加上构造方法
         * 
         * */
        public TaggedWritable() {
			// TODO Auto-generated constructor stub
		}

        public TaggedWritable(Writable data) {  
            this.tag = new Text("");  
            this.data = data;  
        }  

        public Writable getData() {  
            return data;  
        }  

        public void write(DataOutput out) throws IOException {  
            this.tag.write(out);  
            //此行代码很重要
            out.writeUTF(this.data.getClass().getName());

            this.data.write(out); 

        }  

        public void readFields(DataInput in) throws IOException {  
            this.tag.readFields(in);  
              //加入此部分代码，否则，可能报空指针异常
        	String temp=in.readUTF();
			if (this.data == null|| !this.data.getClass().getName().equals(temp)) {
					try {
					this.data = (Writable) ReflectionUtils.newInstance(
					Class.forName(temp), null);
					} catch (ClassNotFoundException e) {
					e.printStackTrace();
					}
					}
            this.data.readFields(in);  
        }  
    }  

    public int run(String[] args) throws Exception {  
        Configuration conf = getConf();  

        JobConf job = new JobConf(conf, DataJoin.class);  

        job.set("mapred.job.tracker","192.168.75.130:9001");
      		读取person中的数据字段
      		 job.setJar("tt.jar");
      	job.setJarByClass(DataJoin.class);
    		System.out.println("模式：  "+job.get("mapred.job.tracker"));;




        String path="hdfs://192.168.75.130:9000/root/outputjoindb";
		FileSystem fs=FileSystem.get(conf);
		Path p=new Path(path);
		if(fs.exists(p)){
			fs.delete(p, true);
			System.out.println("输出路径存在，已删除！");
		}



        Path in = new Path("hdfs://192.168.75.130:9000/root/inputjoindb");  
      //  Path out = new Path(args[1]);  
        FileInputFormat.setInputPaths(job, in);  
        FileOutputFormat.setOutputPath(job, p);  

        job.setJobName("cee");  
        job.setMapperClass(MapClass.class);  
        job.setReducerClass(Reduce.class);  

        job.setInputFormat(TextInputFormat.class);  
        job.setOutputFormat(TextOutputFormat.class);  
        job.setOutputKeyClass(Text.class);  
        job.setOutputValueClass(TaggedWritable.class);  
        job.set("mapred.textoutputformat.separator", ",");  

        JobClient.runJob(job);   
        return 0;  
    }  

    public static void main(String[] args) throws Exception {   



        int res = ToolRunner.run(new Configuration(),  
                                 new DataJoin(),  
                                 args);  

        System.exit(res);  
    }  
}



[b][size=x-large][color=green]运行，日志[/color][/size][/b] 
模式：  192.168.75.130:9001
输出路径存在，已删除！
INFO - NativeCodeLoader.<clinit>(43) | Loaded the native-hadoop library
WARN - LoadSnappy.<clinit>(46) | Snappy native library not loaded
INFO - FileInputFormat.listStatus(199) | Total input paths to process : 2
INFO - JobClient.monitorAndPrintJob(1380) | Running job: job_201404222310_0025
INFO - JobClient.monitorAndPrintJob(1393) |  map 0% reduce 0%
INFO - JobClient.monitorAndPrintJob(1393) |  map 33% reduce 0%
INFO - JobClient.monitorAndPrintJob(1393) |  map 100% reduce 0%
INFO - JobClient.monitorAndPrintJob(1393) |  map 100% reduce 33%
INFO - JobClient.monitorAndPrintJob(1393) |  map 100% reduce 100%
INFO - JobClient.monitorAndPrintJob(1448) | Job complete: job_201404222310_0025
INFO - Counters.log(585) | Counters: 30
INFO - Counters.log(587) |   Job Counters 
INFO - Counters.log(589) |     Launched reduce tasks=1
INFO - Counters.log(589) |     SLOTS_MILLIS_MAPS=14335
INFO - Counters.log(589) |     Total time spent by all reduces waiting after reserving slots (ms)=0
INFO - Counters.log(589) |     Total time spent by all maps waiting after reserving slots (ms)=0
INFO - Counters.log(589) |     Launched map tasks=3
INFO - Counters.log(589) |     Data-local map tasks=3
INFO - Counters.log(589) |     SLOTS_MILLIS_REDUCES=9868
INFO - Counters.log(587) |   File Input Format Counters 
INFO - Counters.log(589) |     Bytes Read=207
INFO - Counters.log(587) |   File Output Format Counters 
INFO - Counters.log(589) |     Bytes Written=172
INFO - Counters.log(587) |   FileSystemCounters
INFO - Counters.log(589) |     FILE_BYTES_READ=837
INFO - Counters.log(589) |     HDFS_BYTES_READ=513
INFO - Counters.log(589) |     FILE_BYTES_WRITTEN=221032
INFO - Counters.log(589) |     HDFS_BYTES_WRITTEN=172
INFO - Counters.log(587) |   Map-Reduce Framework
INFO - Counters.log(589) |     Map output materialized bytes=849
INFO - Counters.log(589) |     Map input records=8
INFO - Counters.log(589) |     Reduce shuffle bytes=849
INFO - Counters.log(589) |     Spilled Records=16
INFO - Counters.log(589) |     Map output bytes=815
INFO - Counters.log(589) |     Total committed heap usage (bytes)=496644096
INFO - Counters.log(589) |     CPU time spent (ms)=2080
INFO - Counters.log(589) |     Map input bytes=187
INFO - Counters.log(589) |     SPLIT_RAW_BYTES=306
INFO - Counters.log(589) |     Combine input records=0
INFO - Counters.log(589) |     Reduce input records=8
INFO - Counters.log(589) |     Reduce input groups=4
INFO - Counters.log(589) |     Combine output records=0
INFO - Counters.log(589) |     Physical memory (bytes) snapshot=623570944
INFO - Counters.log(589) |     Reduce output records=4
INFO - Counters.log(589) |     Virtual memory (bytes) snapshot=2908262400
INFO - Counters.log(589) |     Map output records=8

[b][color=green][size=large]运行结果，如下图所示：[/size][/color][/b]

[img]http://dl2.iteye.com/upload/attachment/0096/3794/5ed842ff-9b59-3931-957d-6d75dc6d0204.jpg[/img]
[b][color=green][size=large]可以看出，MR正确的完成了join操作，需要注意的是Reduce侧连接的不足之处：
之所以会存在reduce join这种方式，我们可以很明显的看出原：因为整体数据被分割了，每个map task只处理一部分数据而不能够获取到所有需要的join字段，因此我们需要在讲join key作为reduce端的分组将所有join key相同的记录集中起来进行处理，所以reduce join这种方式就出现了。这种方式的缺点很明显就是会造成map和reduce端也就是shuffle阶段出现大量的数据传输，效率很低。

另外一点需要注意的是，散仙在eclipse里进行调试，Local模式下会报异常，建议提交到hadoop的测试集群上进行测试。

[/size][/color][/b]
三劫散仙
关注
专栏目录
Hive的ReduceJoin/MapJoin/SMBJoin
someInNeed的博客
03-27 619
Hive中就是把Map，Reduce的Join拿过来，通过SQL来表示。 参考链接：https://cwiki.apache.org/confluence/display/Hive/LanguageManual+Joins 1.Reduce /Common/Shuffle Join Reduce Join在Hive中也叫Common Join或Shuffle Join 如果两边数据量都很大，它会进行把相同key的value合在一起，正好符合我们在sql中的join，然后再去组合，如图所示。 .
MapReduce实现join连接
08-30
简单的在MapReduce中实现两个表的join连接简单的在MapReduce中实现两个表的join连接简单的在MapReduce中实现两个表的join连接
hadoop 两表join处理方法
伤心的驴的专栏
11-17 949
1. 概述 在传统数据库（如：MYSQL）中，JOIN操作是非常常见且非常耗时的。而在HADOOP中进行JOIN操作，同样常见且耗时，由于Hadoop的独特设计思想，当进行JOIN操作时，有一些特殊的技巧。 本文首先介绍了Hadoop上通常的JOIN实现方法，然后给出了几种针对不同输入数据集的优化方法。 2. 常见的join方法介绍 假设要进行join的数据分别来自File1和File2.
Hadoop中MapReduce多种join实现实例分析
疯狂的矩阵
02-11 240
原文：[url]http://database.51cto.com/art/201410/454277.htm[/url] [b]一、概述[/b] 对于RDBMS中的join操作大伙一定非常熟悉，写sql的时候要十分注意细节，稍有差池就会耗时巨久造成很大的性能瓶颈，而在Hadoop中使用MapReduce框架进行join的操作时同样耗时，但是由于hadoop的分布式设计理念的特殊性，因...
MapReduce找出访问量最大的表
Switfy的博客
08-22 813
一、在网上找的题就做了，需要借助一个Bean对象来实现排序 编写MapReduce程序算出高峰时间段（9-10点）哪张表被访问的最频繁 1.  /** 2.   * 用Hadoop分析海量日志文件，每行日志记录了如下数据： 3.    4.   * TableName(表名)，Time(时间)，User(用户)，TimeSpan(时间开销) 5.    6.  
HBase 中mapreduce join的使用
酸奶王子
08-06 365
[b][size=x-large]首先介绍常用的几种 mapreduce 方法[/size][/b] [color=red][b][size=large]reduce side join[/size][/b][/color] [b]reduce side join是一种最简单的join方式，其主要思想如下： 在map阶段，map函数同时读取两个文件File1和File2，为了区分两种来源的k...
19、Join操作map side join 和 reduce side join
最新发布
05-29
在大数据处理领域，Hadoop MapReduce 是一种广泛使用的分布式计算框架。在处理涉及多数据集的任务时，Join 操作是必不可少的，它用于合并来自不同数据源的相关数据。本文主要探讨了两种 MapReduce 中的 Join 实现：...
hadoop_join.jar.zip_hadoop_hadoop query_reduce
09-20
通常，Hadoop中的Join可以分为几种类型：Bucket Join、Sort-Merge Join、Replicated Join和Map-Side Join等。每种Join策略都有其适用场景和优缺点。 `hadoop_join.jar`是一个针对Hadoop环境设计的Join查询工具，它...
在Hadoop Map-Reduce中实施联接
04-04
5. **Three-way Join 和 Multi-way Join**：对于更多的数据集，可以扩展Reduce-Side Join的概念，但可能会增加复杂性和性能挑战。通常需要更复杂的分区策略和数据预处理。 在实现Join时，还需要考虑以下优化策略： ...
hadoop_join_aggregate:在hadoop中加入和聚合mapreduce算法
06-05
Map side join 比 reducer side join 快。 但是只有当您执行映射端连接操作的表之一小到足以放入内存时，映射端连接才足够。 日期集信息 客户数据集：每行包含：CustID、Name、Age、CountryCode、Salary。 交易...
MapReduce编程Join的多种应用之适用于一张表十分小、一张表很大的场景，采用Cache缓存
qq_51903852的博客
11-03 113
customers.csv格式 1,Richard,Hernandez,XXXXXXXXX,XXXXXXXXX,6303 Heather Plaza,Brownsville,TX,78521 2,Mary,Barrett,XXXXXXXXX,XXXXXXXXX,9526 Noble Embers Ridge,Littleton,CO,80126 3,Ann,Smith,XXXXXXXXX,XXXXXXXXX,3422 Blue Pioneer Bend,Caguas,PR,725 ...... order
大数据学习03：MapReduce及Bigtable简单介绍
weixin_44804248的博客
03-22 627
MapReduce及Bigtable简单介绍 MapReduce的编程模型：先拆分、再合并 HDFS = NameNode+SecondaryNameNode+DataNode 求和：大任务=小任务1+小任务2+......完事再合并 BigTable：大表------NoSQL数据库：HBase 1、关系型数据库：Oracle、MySql等等----->行式数据库----->i...
MapReduce 中的两表 join 几种方案简介
wisgood的专栏
12-09 1293
1. 概述 在传统数据库（如：MYSQL）中，JOIN操作是非常常见且非常耗时的。而在HADOOP中进行JOIN操作，同样常见且耗时，由于Hadoop的独特设计思想，当进行JOIN操作时，有一些特殊的技巧。 本文首先介绍了Hadoop上通常的JOIN实现方法，然后给出了几种针对不同输入数据集的优化方法。 2. 常见的join方法介绍 假设要进行join的数据分别来自File
Cassandra数据库入门-1
长河的博客
03-02 1774
Cassandra系列教程-1 ，入门介绍
Kettle-根据源表（source table）数据更新情况对目标表（target table）中数据进行删除
shen_xy的博客
06-25 5628
应用场景：    目标表的数据是从源表中抽取的，当源表数据删除时，希望目标表中的数据也能及时删除。转换思路：    两个表中的数据进行合并记录操作，合并后的数据会根据对比情况打上标签，过滤出标签为deleted的数据，对其进行删除操作。转换过程：    注意：在对两表进行合并记录操作之前，需要将两表分别进行排序操作，可以直接在表输入的sql脚本中使用order by进行排序，也可以分别在表输入和合...
MapReduce表连接之半连接SemiJoin
lavimer
01-22 5475
一：背景 SemiJoin，一般称为半连接，其原理是在Map端过滤掉一些不需要join的数据，从而大大减少了reduce和Shuffle的时间，因为我们知道，如果仅仅使用Reduce端连接，那么如果一份数据，存在大量的无效数据，而这些数据在join中并不需要，但是因为没有做过预处理，所以这些数据直到真正执行reduce函数时，才被定义为无效数据，但是这个时候已经执行过了Shuffle、merge
MapReduce-Join中级优化-hadoop自带datajoin的解决方法
Qi.zheng
01-29 1614
接着上一篇《》这一篇博客继续说明MapReduce对于Join的操作，这里使用hadoop包中自带的datajoin包来处理，如果是hadoop1.x则包在${HADOOP_HOME}/contrib/datajoin文件夹下。如果是hadoop2.x则该包在${HADOOP_HOME}/share/hadoop/tools/lib下面把包引入工程中就可以使用了。 以下是本篇博客要处理的数据，为
MapReduce实现两表的Join--原理及python和java代码实现
热门推荐
William Zhao's notes
05-25 1万+
用Hive一句话搞定的，但是有时必须要用mapreduce 方法介绍 1. 概述 在传统数据库（如：MYSQL）中，JOIN操作是非常常见且非常耗时的。而在HADOOP中进行JOIN操作，同样常见且耗时，由于Hadoop的独特设计思想，当进行JOIN操作时，有一些特殊的技巧。 本文首先介绍了Hadoop上通常的JOIN实现方法，然后给出了几种针对不同输入数据集的优化方法。 2. 常见
MapReduce Join操作解析：MapSide Join与ReduceSide Join
"本文主要介绍了MapReduce框架中的两种JOIN操作：Map Side Join和Reduce Side Join，以及它们在处理分布式数据集关联时的应用和优缺点。" MapReduce是一种用于处理和生成大数据集的分布式计算模型，它由两个主要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值