MapReduce实现CommonJoin和MapJoin

最新推荐文章于 2023-07-13 20:45:00 发布
最新推荐文章于 2023-07-13 20:45:00 发布
阅读量1.3k 收藏
点赞数 1
分类专栏： Hadoop 文章标签： mapreduce
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lemonzhaotao/article/details/78209708
版权

##CommnoJoin和MapJoin简介

CommonJoin即传统思路实现Join，性能较差 因为涉及到了shuffle的过程
common join/shuffle join/reduce join (都是指同一个)
MapJoin 也叫作 boardcast join，但是MapJoin不会有reduce阶段和shuffle阶段

本篇文章，将对CommonJoin和MapJoin，通过MapReduce进行实现
将有助于理解后续的Hive中的Join

##CommnJoin的MapReduce实现

CommonJoinMap

package com.zhaotao.bigdata.commonjoin;

import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.lib.input.FileSplit;

import java.io.IOException;

/**
 * Created by 陶 on 2017/10/9.
 */
public class CommonJoinMap extends Mapper<LongWritable, Text, Text, Text>{

    @Override
    protected void map(LongWritable key, Text value, Mapper<LongWritable, Text, Text, Text>.Context context)
            throws IOException, InterruptedException {

        // 获取输入文件的全路径和名称
        FileSplit fileSplit = (FileSplit) context.getInputSplit();
        String path = fileSplit.getPath().toString();

        // 获取输入记录的字符串
        String line = value.toString();
        
        // 处理来自emp表的记录
        if (path.contains("emp")){
            // 按空格切割
            String[] values = line.split(" ");
            // 获取emp表的部门编号和员工名字
            String deptNo = values[7];
            String empName = values[1];

            // 把结果写出去，打标签
            context.write(new Text(deptNo), new Text("a#" + empName));
        } else if (path.contains("dept")){
            // 按空格符切割
            String[] values = line.split(" ");
            // 获取dept表的部门编号、部门名称、城市
            String deptNo = values[0];
            String deptName = values[1];
            String city = values[2];

            // 把结果写出去，打标签
            context.write(new Text(deptNo), new Text("b#" + deptName + " " + city));
        }
    }
    
}

CommonJoinReduce

package com.zhaotao.bigdata.commonjoin;

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

import java.io.IOException;
import java.util.Vector;

/**
 * Created by 陶 on 2017/10/9.
 */
public class CommonJoinReduce extends Reducer<Text, Text, Text, Text>{

    @Override
    protected void reduce(Text key, Iterable<Text> values, Reducer<Text, Text, Text, Text>.Context context)
            throws IOException, InterruptedException {

        // 用于存放来自emp表的数据
        Vector<String> vectorA = new Vector<String>();
        // 用于存放来自dept表的数据
        Vector<String> vectorB = new Vector<String>();

        // 迭代集合数据
        for (Text val : values){
            // 将集合中的数据 对应 添加到  相应的  Vector中去
            // 根据标签 ，将 a# 和 b# 之后的数据全部提取出来
            // 相当于去除标签
            if (val.toString().startsWith("a#")){
                vectorA.add(val.toString().substring(2));
            } else if (val.toString().startsWith("b#")){
                vectorB.add(val.toString().substring(2));
            }
        }

        // 获取两个Vector集合的长度
        int sizeA = vectorA.size();
        int sizeB = vectorB.size();

        // 遍历两个向量，将结果写出去
        for (int i = 0 ; i < sizeA ; i ++){
            for (int j = 0 ; j < sizeB ; j ++){
                context.write(key, new Text(" " + vectorA.get(i) + " " + vectorB.get(j)));
            }
        }
    }

}

CommonJoinDriver

package com.zhaotao.bigdata.commonjoin;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.input.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;

import java.net.URI;

/**
 * Created by 陶 on 2017/10/9.
 */
public class CommonJoinDriver {

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

        // 定义输入路径
        String INPUT_PATH = "/input/*";
        // 定义输出路径
        String OUT_PATH = "/out/commonjoin_out";

        // 创建配置信息
        Configuration conf = new Configuration();

        // 创建文件系统
        FileSystem fileSystem = FileSystem.get(new URI(OUT_PATH), conf);
        // 如果输出目录存在，我们就删除
        if (fileSystem.exists(new Path(OUT_PATH))) {
            fileSystem.delete(new Path(OUT_PATH), true);
        }

        // 创建任务
        Job job = new Job(conf, CommonJoinDriver.class.getName());

        // 打成jar包运行，这句话是关键
        job.setJarByClass(CommonJoinDriver.class);

        // 设置输入目录和设置输入数据格式化的类
        FileInputFormat.setInputPaths(job, INPUT_PATH);
        job.setInputFormatClass(TextInputFormat.class);

        // 设置自定义Mapper类和设置map函数输出数据的key和value的类型
        job.setMapperClass(CommonJoinMap.class);
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(Text.class);

        // 指定Reducer类和输出key和value的类型
        job.setReducerClass(CommonJoinReduce.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(Text.class);

        // 指定输出的路径和设置输出的格式化类
        FileOutputFormat.setOutputPath(job, new Path(OUT_PATH));
        job.setOutputFormatClass(TextOutputFormat.class);


        // 提交作业 退出
        System.exit(job.waitForCompletion(true) ? 0 : 1);
    }

}

##CommonJoin结果
这里写图片描述

##MapJoin的MapReduce实现

MapJoinMapper

package com.zhaotao.bigdata.mapjoin;

import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.filecache.DistributedCache;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

/**
 * Created by 陶 on 2017/10/10.
 */
public class MapJoinMapper extends Mapper<LongWritable, Text, Text, Text>{

    private Map<String, String> joinData = new HashMap<String, String>();

    /**
     * 读取小表数据
     * 使用DistributedCache，将数据缓存到分布式内存中来
     * @param context
     * @throws IOException
     * @throws InterruptedException
     */
    @Override
    protected void setup(Context context) throws IOException, InterruptedException {
        // 预处理把要关联的文件加载到缓存中来
        Path[] paths = DistributedCache.getLocalCacheFiles(context.getConfiguration());
        System.out.println(paths[0]);
        // 创建BufferReader去读取小表
        BufferedReader reader = new BufferedReader(new FileReader(paths[0].toString()));

        String str = null;
        try {
            // 一行一行读取
            while ((str = reader.readLine()) != null){
                // 对缓存中小表(dept表)的数据进行切割
                String[] splits = str.split(" ");
                // 把字符数组中有用的数据存在一个Map中
                // 部门编号  部门名称
                joinData.put(splits[0],splits[1]);
            }
        } catch (Exception e){
            e.printStackTrace();
        } finally {
            reader.close();
        }
    }

    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        // 获取从HDFS中加载的大表(emp表)
        String[] values = value.toString().split(" ");
        String empName = values[1];
        // 获取关联的字段deptNo，这个字段是关键
        String deptNo = values[7];
        // 根据从内存中的关联表中获取要关联的属性deptName
        String deptName = joinData.get(deptNo);

        // 写出去
        context.write(new Text(deptNo), new Text(empName + " " + deptName));
    }
}

MapJoinDriver

package com.zhaotao.bigdata.mapjoin;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.filecache.DistributedCache;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.input.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;

import java.net.URI;

/**
 * 因为涉及到分布式缓存，只能放在集群环境下跑
 *
 * Created by 陶 on 2017/10/10.
 */
public class MapJoinDriver {

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

        // 定义输入路径
        String INPUT_PATH1 = "/input/emp.txt";
        // 加载到内存的表的路径
        String INPUT_PATH2 = "/input/dept.txt";
        // 定义输出路径
        String OUT_PATH = "/out/mapjoin_out";

        // 创建配置信息
        Configuration conf = new Configuration();

        // 创建文件系统
        FileSystem fileSystem = FileSystem.get(new URI(OUT_PATH), conf);

        // 如果输出目录存在，我们就删除
        if (fileSystem.exists(new Path(OUT_PATH))) {
            fileSystem.delete(new Path(OUT_PATH), true);
        }

        // 添加到内存中的文件(随便添加多少个文件)
        DistributedCache.addCacheFile(new Path(INPUT_PATH2).toUri(), conf);

        // 创建任务
        Job job = new Job(conf, MapJoinDriver.class.getName());

        // 打成jar包运行，这句话是关键
        job.setJarByClass(MapJoinDriver.class);

        // 设置输入目录和设置输入数据格式化的类
        FileInputFormat.setInputPaths(job, INPUT_PATH1);
        job.setInputFormatClass(TextInputFormat.class);

        // 设置自定义Mapper类和设置map函数输出数据的key和value的类型
        job.setMapperClass(MapJoinMapper.class);
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(Text.class);

        job.setNumReduceTasks(0);

        FileOutputFormat.setOutputPath(job, new Path(OUT_PATH));
        job.setOutputFormatClass(TextOutputFormat.class);
        // 提交作业 退出
        System.exit(job.waitForCompletion(true) ? 0 : 1);

    }

}

##MapJoin运行结果

运行结果：
这里写图片描述

验证没有reduce，没有shuffle过程：
这里写图片描述

疯狂呼呼呼
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MapReduce框架-Join的使用
zyd_994264926326的博客
08-13 1038
目录 一、引言 二、关系型数据库MySQL中Join的用法 笛卡尔积：CROSS JOIN 内连接：INNER JOIN 左连接：LEFT JOIN 右连接：RIGHT JOIN 外连接：OUTER JOIN 三、Reduce Join 1. Reduce Join介绍 2. 案例 2.1 需求： 2.2 实现思路：reduce端表合并（数据倾斜） 2.3 步骤 2.4 源代码 2.5 运行截图 3.Reduce Join缺点 四、Map Join 1. 使用场景 2.
joinmap4.0软件
02-08
构建遗传连锁图工具，是进行QTL分析等的必须前奏工作。
【大数据之Hive】二十二、HQL语法优化之Join优化
最新发布
阿宁的博客
07-13 429
Map Join算法可以通过两个只有map阶段的Job完成一个join操作。适用于大表join小表。第一个Job会读取小表数据，将其制作为hash table，并上传至Hadoop分布式缓存（本质上是上传至HDFS）。第二个Job会先从分布式缓存中读取小表数据，并缓存在Map Task的内存中，然后扫描大表数据，在map端即可完成关联操作。Bucket Map Join是对Map Join算法的改进，其打破了Map Join只适用于大表join小表的限制，可用于大表join大表的场景。
hadoop--Map Join
FunnyPrince_的博客
09-14 257
。。。。
Map join和Common join详解
热门推荐
weixin_39216383的博客
01-12 1万+
利用hive进行join连接操作，相较于MR有两种执行方案，一种为common join，另一种为map join ，map join是相对于common join的一种优化，省去shullfe和reduce的过程，大大的降低的作业运行的时间。 一.先决条件 emp表 hive> select * from emp; OK 369 SMITH CLERK 7902 19
Mapreduce实例（八）：Map端join
笑看风云路的博客
06-01 439
MR实现Map端join
mapreduce之mapjoin
会飞的鱼
01-13 1390
mapjoin指的是在mapreduce的map阶段先加载一个文件缓存到内存当中，这个文件可能是从磁盘读取的或网络请求的都可以。 map(key,value,context)方法中读取的数据key和value，这两个数据和先前缓存到内存中的数据一起做处理后再context.write()到reduce阶段。 mapjoin相当于在map阶段写数据到reduce阶段前对数据做了处理。 比如有两个tx...
【MapReduce篇06】MapReduce之MapJoin和ReduceJoin1
08-04
今天，我们将讲解 MapReduce 之 MapJoin 和 ReduceJoin 两种 Join 操作的实现原理和应用场景。 MapJoin 概述 MapJoin 是一种特殊的 Join 操作，通过在 Map 阶段对数据进行 Join 操作，减少了 Reduce 阶段的数据...
MapReduce之Join操作
01-30
在关系型数据库中 ...MapReduce编程模型，也有相应的处理措施和优化方法。本文对Hadoop中最基本的join方法进行简单介绍，这也是其它许多方法和优化措施的基础。文中所采用的例子来自于《 HadoopinAc
MapReduce实现join连接
08-30
简单的在MapReduce中实现两个表的join连接简单的在MapReduce中实现两个表的join连接简单的在MapReduce中实现两个表的join连接
19、Join操作map side join 和 reduce side join
05-29
19、Join操作map side join 和 reduce side join 网址：https://blog.csdn.net/chenwewi520feng/article/details/130455477 本文介绍mapreduce的join操作。 本文前提是hadoop可以正常使用。 本文分为3个部分介绍，即...
通过Map-Reduce实现Join系列之四
04-14
NULL 博文链接：https://mysun.iteye.com/blog/1748484
MapReduce之Map Join
weixin_34503526的博客
04-03 215
如果在Reduce 端处理过多的表，容易出现数据倾斜，通常我们会在Map端缓存起来，提前把处理业务逻辑，减少Reduce端数据的压力，减少数据倾斜。 Map Join 适用于一张表十分小、一张表很大的场景。 Mapper的setup（初始化）的时候缓存到集合中， job.addCacheFile(new URI("file:///D:/input/tablecache/pd.txt")); 代码如下： public class MapJoinMapper extends Mapper.
MapReduce之MapJoin案例
Sun's Blog
08-17 228
文章目录**使用场景****优点****具体办法**：采用`DistributedCache`案例需求分析代码实现 使用场景 Map Join 适用于一张表十分小、一张表很大的场景。 优点 思考：在Reduce 端处理过多的表，非常容易产生数据倾斜。怎么办？ 在Map端缓存多张表，提前处理业务逻辑，这样增加Map 端业务，减少Reduce 端数据的压力，尽可能的减少数据倾斜。 具体办法：采用DistributedCache （1）在Mapper的setup阶段，将文件读取到缓存集合中。 （2）在驱动函数中加
使用MapReduce实现两个文件的Join操作
Harm灬小海的博客
04-26 3570
文章目录数据结构customerorderMapJoin描述主函数入口构造类代码执行结果(MapJoin采坑记录)[] 数据结构 customer USER_ID NAME PHONE 1 大树 13111111111 2 小十七 13122222222 3 小海 13133333333 4 jeff 13100000000 5 zz 13155555555 6...
Hadoop之MapReduce的Join解析
勇心在馨
01-30 845
代码存于github:https://github.com/zuodaoyong/Hadoop 1、Reduce Join（会出现数据倾斜） 通过将关联条件作为Map输出的key，将两表满足Join条件的数据并携带数据所来源的文件信息，发往同一个ReduceTask，在Reduce中进行数据的串联 需求：将商品信息表中数据根据商品pid合并到订单数据表中 订单数据： Id ...
Hadoop中Join多种应用
南国的技术栈
01-15 562
今天，南国在网上看到一篇不错的文章总结，也是我之前没有深入学习的一个知识点。在这里，对知识点做一个简要的概括和案例分析。 总结： Join： 将两个中的字段，通过公共字段进行关联！ MR ： ①在Reduce端Join 1.保证两个文件中的所有字段，都必须达到Reduce!需要将两个文件的所有字段封装为一个Bean 2.在Map端，为每个文件，打上标记 弊端：如果数据量大，reduce端处理过程耗...
Hadoop中MapReduce多种join实现实例分析
An342647823的专栏
07-13 3967
感谢分享：http://database.51cto.com/art/201410/454277.htm 1、在Reudce端进行连接。 在Reudce端进行连接是MapReduce框架进行表之间join操作最为常见的模式，其具体的实现原理如下： Map端的主要工作：为来自不同表（文件）的key/value对打标签以区别不同来源的记录。然后用连接字段作为key，其余部分和新加的标志作为v
hive的Reduce join与Map join
Realoyou的博客
02-01 2828
说明 hive 中的join可分为俩类，一种是common join（也叫Reduce join或shuffle join),另一种是 map join，后者是对hive join的一个优化，利用本地的task对较小的表hash生产一个hashtable文件，然后直接和map出来另一个表进行匹配，最终完成join\ set hive.auto.convert.join = false 在0.7...
MapReduce实现join操作
06-02
在MapReduce中实现join操作通常有两种方式：Reduce-side join和Map-side join。 1. Reduce-side join： Reduce-side join是最常用的实现方式。它的基本思想是将两个需要join的表分别映射为(key, value)的形式，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值