MapReduce之join

最新推荐文章于 2022-03-29 14:56:14 发布
原创 最新推荐文章于 2022-03-29 14:56:14 发布 · 358 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#hadoop #大数据 #mapreduce #join #mapjoin

博客主要介绍了Hadoop中ReduceJoin和MapJoin两种join操作。ReduceJoin在map阶段读取数据并添加表名信息，reduce阶段完成join，会产生shuffle；MapJoin只有map阶段，通过cache加载数据直接在map端完成join，无shuffle，仅适用于小表。还给出了相关数据示例及代码模块。

假设现在是A.joinB

  • ReduceJoin：在map阶段先后读取A和B，通过在mapper的setup方法中获取当前正在读取的表名，并将表名信息添加到Bean对象中；在reduce阶段，A和B中相同key的数据被放到同一个reducer中，通过map阶段添加的表名信息先将reducer的value分成来自A的Aarray和来自B的Barray，遍历Aarray和Barray即可完成join操作；
  • MapJoin：只有map阶段无reduce阶段，通过cache的方式先将要B加载到map的计算节点，然后在map端直接完成join；
  • 分析
  1. ReduceJoin的每个map只获取到了B的部分信息，因此必须通过reduce阶段才能完成join，经过reduce会产生shuffle；
  2. MapJoin的每个map均获取到了B的全部信息，因此仅需map阶段即可完成join，无reduce因此不产生shuffle；
  3. MapJoin因为每个map均需要加载B的全部信息，因此仅当B为小表时适用。
1.ReduceJoin

  • 数据
    order.txt
    orderId,prodId,saleVol
    1,001,123
    2,001,222
    3,003,12
    4,002,34
    5,009,32
    6,001,12
    7,009,2
    8,007,123
    9,007,123
    10,008,33
    11,008,32

    proInfo.txt
    prodId,prodName,prodPrice
    001,小米1,1234
    002,小米2,222
    003,小米3,333
    004,华为1,111
    005,华为2,222
    006,华为3,444
    007,华为4,333
    008,华为5,321
    009,一加1,222

  • Bean

import org.apache.hadoop.io.Writable;

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

public class OrderBean implements Writable {
    private String orderId;
    private String prodId;
    private int saleVol;
    private String prodName;
    private float prodPrice;
    private String tag;

    public float getProdPrice() {
        return prodPrice;
    }

    public int getSaleVol() {
        return saleVol;
    }

    public String getOrderId() {
        return orderId;
    }

    public String getProdId() {
        return prodId;
    }

    public String getProdName() {
        return prodName;
    }

    public String getTag() {
        return tag;
    }

    public void setOrderId(String orderId) {
        this.orderId = orderId;
    }

    public void setProdId(String prodId) {
        this.prodId = prodId;
    }

    public void setProdName(String prodName) {
        this.prodName = prodName;
    }

    public void setProdPrice(float prodPrice) {
        this.prodPrice = prodPrice;
    }

    public void setSaleVol(int saleVol) {
        this.saleVol = saleVol;
    }

    public void setTag(String tag) {
        this.tag = tag;
    }

    public void write(DataOutput dataOutput) throws IOException {
        dataOutput.writeUTF(this.orderId);
        dataOutput.writeUTF(this.prodId);
        dataOutput.writeInt(this.saleVol);
        dataOutput.writeUTF(this.prodName);
        dataOutput.writeFloat(this.prodPrice);
        dataOutput.writeUTF(this.tag);
    }

    public void readFields(DataInput dataInput) throws IOException {
        this.orderId = dataInput.readUTF();
        this.prodId = dataInput.readUTF();
        this.saleVol = dataInput.readInt();
        this.prodName = dataInput.readUTF();
        this.prodPrice = dataInput.readFloat();
        this.tag = dataInput.readUTF();
    }

    @Override
    public String toString() {
        return  "orderId='" + orderId + '\'' +
                ", prodId='" + prodId + '\'' +
                ", prodName='" + prodName + '\'' +
                ", prodPrice=" + prodPrice +
                ", tag=" + tag;
    }
}
  • Mapper
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;

public class RJMapper extends Mapper<LongWritable,Text, Text,OrderBean> {
    private String tableName;
    private Text mapKey = new Text();
    @Override
    protected void setup(Context context) throws IOException, InterruptedException {
        FileSplit inputSplit = (FileSplit) context.getInputSplit();
        tableName = inputSplit.getPath().getName();
    }

    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        String line = value.toString();
        String[] fields = line.split(",");
        OrderBean orderBean = new OrderBean();
        if(tableName.startsWith("order")){
            orderBean.setOrderId(fields[0]);
            orderBean.setProdId(fields[1]);
            orderBean.setSaleVol(Integer.parseInt(fields[2]));
            orderBean.setProdName("");
            orderBean.setProdPrice(0);
            orderBean.setTag("order");

        } else if(tableName.startsWith("proInfo")){
            orderBean.setProdId(fields[0]);
            orderBean.setProdName(fields[1]);
            orderBean.setProdPrice(Float.parseFloat(fields[2]));
            orderBean.setOrderId("");
            orderBean.setSaleVol(0);
            orderBean.setTag("proInfo");
        }
        mapKey.set(orderBean.getProdId());
        context.write(mapKey,orderBean);
    }
}
  • Reducer
import com.sun.org.apache.xpath.internal.operations.Or;
import org.apache.commons.beanutils.BeanUtils;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

import javax.xml.bind.SchemaOutputResolver;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;

public class RJReducer extends Reducer<Text,OrderBean,Text,OrderBean> {

    @Override
    protected void reduce(Text key, Iterable<OrderBean> values, Context context) throws IOException, InterruptedException {
        ArrayList<OrderBean> orderList = new ArrayList<OrderBean>();
        ArrayList<OrderBean> infoList = new ArrayList<OrderBean>();

        for(OrderBean orderBean:values){
            OrderBean tmpOrderBean = new OrderBean();
            try {
                BeanUtils.copyProperties(tmpOrderBean,orderBean);
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }

            if(orderBean.getTag().equals("order")){
                orderList.add(tmpOrderBean);
            } else if(orderBean.getTag().equals("proInfo")){
                infoList.add(tmpOrderBean);
            }else{
                System.out.println("errrrrrrrrrrr");
            }
        }

        String prodId;
        for(OrderBean orderBean:orderList){
            prodId = orderBean.getProdId();
            for(OrderBean infoBean:infoList){
                if(infoBean.getProdId().equals(prodId)){
                    orderBean.setProdName(infoBean.getProdName());
                    orderBean.setProdPrice(infoBean.getProdPrice());
                    break;
                }
            }
            context.write(key,orderBean);
        }
    }
}
  • Driver
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.output.FileOutputFormat;
import org.apache.log4j.BasicConfigurator;

import java.io.IOException;

public class RJDriver {
    private static String HDFS_HOST = "hdfs://dong:9000";
    private static String INPUT_PATH = "hdfs:///data/joinTest";
    private static String OUTPUT_PATH = "hdfs:///data/result/joinResult";

    public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
        BasicConfigurator.configure();
        Configuration conf = new Configuration();
        conf.set("fs.defaultFS",HDFS_HOST);

        Job job = Job.getInstance(conf);
        job.setJarByClass(RJDriver.class);
        job.setMapperClass(RJMapper.class);
        job.setReducerClass(RJReducer.class);

        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(OrderBean.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(OrderBean.class);

        Path inputPath = new Path(INPUT_PATH);
        Path outputPath = new Path(OUTPUT_PATH);

        FileInputFormat.setInputPaths(job,inputPath);
        FileOutputFormat.setOutputPath(job,outputPath);

        FileSystem fileSystem = FileSystem.get(conf);
        if(fileSystem.exists(outputPath)){
            fileSystem.delete(outputPath,true);
        }

        boolean result = job.waitForCompletion(true);
        System.exit(result?0:1);
    }
}
2.MapJoin
  • Bean
import org.apache.hadoop.io.Writable;

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

public class OrderBean implements Writable {
    private String orderId;
    private String prodId;
    private int saleVol;
    private String prodName;
    private float prodPrice;


    public float getProdPrice() {
        return prodPrice;
    }

    public int getSaleVol() {
        return saleVol;
    }

    public String getOrderId() {
        return orderId;
    }

    public String getProdId() {
        return prodId;
    }

    public String getProdName() {
        return prodName;
    }

    public void setOrderId(String orderId) {
        this.orderId = orderId;
    }

    public void setProdId(String prodId) {
        this.prodId = prodId;
    }

    public void setProdName(String prodName) {
        this.prodName = prodName;
    }

    public void setProdPrice(float prodPrice) {
        this.prodPrice = prodPrice;
    }

    public void setSaleVol(int saleVol) {
        this.saleVol = saleVol;
    }

    public void write(DataOutput dataOutput) throws IOException {
        dataOutput.writeUTF(this.orderId);
        dataOutput.writeUTF(this.prodId);
        dataOutput.writeInt(this.saleVol);
        dataOutput.writeUTF(this.prodName);
        dataOutput.writeFloat(this.prodPrice);
    }

    public void readFields(DataInput dataInput) throws IOException {
        this.orderId = dataInput.readUTF();
        this.prodId = dataInput.readUTF();
        this.saleVol = dataInput.readInt();
        this.prodName = dataInput.readUTF();
        this.prodPrice = dataInput.readFloat();
    }

    @Override
    public String toString() {
        return  "orderId='" + orderId + '\'' +
                ", prodId='" + prodId + '\'' +
                ", prodName='" + prodName + '\'' +
                ", prodPrice=" + prodPrice;
    }
}
  • Mapper
import org.apache.commons.lang.StringUtils;
import org.apache.hadoop.io.IOUtils;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

import java.io.*;
import java.util.HashMap;

public class MJMapper extends Mapper<LongWritable, Text,Text,OrderBean> {
    HashMap hashMap = new HashMap<String, String>();
    Text mapKey = new Text();
    @Override
    protected void setup(Context context) throws IOException {
        FileReader fr = new FileReader("proInfo.txt");
        BufferedReader reader = new BufferedReader(fr);
        String line;
        String[] fields;
        //001,小米1,1234

        while(StringUtils.isNotEmpty(line = reader.readLine())){
            fields = line.split(",");
            String val = fields[1] + "," + fields[2];
            hashMap.put(fields[0],val);
        }
        IOUtils.closeStream(reader);
    }

    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        //1,001,123
        String line = value.toString();
        String[] fields = line.split(",");
        OrderBean orderBean = new OrderBean();
        orderBean.setOrderId(fields[0]);
        orderBean.setProdId(fields[1]);
        orderBean.setSaleVol(Integer.parseInt(fields[2]));
        String tmpProdInfo = (String) hashMap.get(orderBean.getProdId());
        String[] prodInfo = tmpProdInfo.split(",");
        orderBean.setProdName(prodInfo[0]);
        orderBean.setProdPrice(Float.parseFloat(prodInfo[1]));
        mapKey.set(orderBean.getProdId());
        context.write(mapKey,orderBean);
    }
}
  • Driver
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.filecache.DistributedCache;
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.output.FileOutputFormat;
import org.apache.log4j.BasicConfigurator;
import org.jets3t.service.model.cloudfront.Distribution;

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

public class MJDriver {
    private static String HDFS_HOST = "hdfs://dong:9000";
    private static String INPUT_PATH = "hdfs:///data/joinTest";
    private static String OUTPUT_PATH = "hdfs:///data/result/joinResult";

    public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException, URISyntaxException {
        BasicConfigurator.configure();
        Configuration conf = new Configuration();
        conf.set("fs.defaultFS",HDFS_HOST);

        Job job = Job.getInstance(conf);
        job.setJarByClass(MJDriver.class);
        job.setMapperClass(MJMapper.class);

        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(OrderBean.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(OrderBean.class);

        Path inputPath = new Path(INPUT_PATH);
        Path outputPath = new Path(OUTPUT_PATH);

        FileInputFormat.setInputPaths(job,inputPath);
        FileOutputFormat.setOutputPath(job,outputPath);
        job.addCacheFile(new URI( "hdfs://dong:9000/data/proInfo.txt"));
        //DistributedCache.addCacheArchive(new URI( "hdfs:///data/proInfo.txt"),conf);
        job.setNumReduceTasks(0);
        FileSystem fileSystem = FileSystem.get(conf);
        if(fileSystem.exists(outputPath)){
            fileSystem.delete(outputPath,true);
        }

        boolean result = job.waitForCompletion(true);
        System.exit(result?0:1);
    }
}
MapReduce之Map阶段的join操作案例
QYHuiiQ
06-08 462
在这个案例中我们要实现的是Map端的join，通常情况下我们会将小表放在分布式缓存中，然后将大表通过正常的map阶段与小表进行join，得到一个join之后的结果，这样map之后的结果就是我们想要的结果，那么就不需要reduce了，所以在该案例中，我们只需要自定义Mapper和主类即可。沿用上一个案例中的两个表，我们把学生基本信息表作为小表，把成绩表作为大表。先将数据文件放入HDFS中： 我们需要在程序启动时就将小表的数据文件放入分布式缓存中，这一步骤需要在主类中配置才能实现。新建project：
MapReduce端Join操作（Map端join、Reduce端join）
zp17834994071的博客
06-08 791
map端join 指有两种表，只是一张较小，一张较大（一般大于1万条数据），大表的信息完全可以覆盖小表，往往将较小的表以键值对的形式添加到内存中，，然后只扫描大表：对于大表中的每一条记录key/value，在小表中查找是否有相同的key的记录，如果有，则连接后输出即可。 Map端join是数据到达map处理函数之前进行合并的，效率要远远高于Reduce端join，因为Reduce端join是把所有的数据都经过Shuffle，非常消耗资源。所以一般都用Map端join。 操作流程 1.以键值对形式存储小表信息
MapReduce实现join操作
youzi_qiu7的博客
09-24 978
文章目录一.概述二.需求三.map+reduce实现join四.MapReduce Map端 join实现原理(没有reduce处理) 一.概述 熟悉SQL的读者都知道,使用SQL语法实现join是很简单的,只需要一条SQL语句即可,但是在大数据场景下使用MapReduce编程模型实现join还是比较繁琐的在实际生产中我们可以借助Hive,Spark SQL 等框架来实现join,但是对于join的实现原理我们需要掌握,这对于理解join的底层实现很有帮助,本文介绍如何使用MapReduce API 来实现
MapReduce的Join操作
清风竹雨
12-07 413
背景 前几日在微信的大数据技术交流群中，有水友面试深圳的某家证券公司并将部分笔试题发出来了，广大水友就开始讨论起来了；当然作为吃瓜群众中的一员我不仅吃了瓜还丢了籽！嘿嘿，当然也记录下来了，下面请看题： 题目 在关系型数据库中的差运算在MR中是如何实现的。假设两个表R、T，现需要计算R-T，找出R中存在T中不存在的数据。 分析 首先限定了是在 MR环境中。 “关系型数据库中的差运算”说明...
MapReduce框架-Join的使用
zyd_994264926326的博客
08-13 1674
目录 一、引言 二、关系型数据库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.
mapReduce 的join
曾一航bd
10-08 631
mapreduce join分为两种： 1、map的join     2、reduce的join 思路： 1、map的join是将一个数据集的数据放入Map集合中，将集合在setup放入到缓存中，所以涉及DistributedCache，因为涉及在内存，所以放入缓存的数据集样本要小，否则不适用，所以这个业务场景比较少 setup中代码实现如下：（官网有源码） @Override ...
MapReduce Join
weixin_47243236的博客
11-29 1361
1. MapReduce Join 1.1 Join join 常使用在数据库中，例如内连接、外连接。在大数据应用中，MapReduce Join 能够解决数据的连接问题。 1.2 MapReduce Join 的分类 Join 实现的方法有两种：Reduce Join、Map Join ???? Reduce Join： Map端：为不同文件的 key/value 打上标签来区分，用连接的字段作为key，value可以用当前行的所有内容，并且为value添加标识。 reduce端：获取来在map处理后
MapReduce之Join操作
01-30
在关系型数据库中 ...MapReduce编程模型，也有相应的处理措施和优化方法。本文对Hadoop中最基本的join方法进行简单介绍，这也是其它许多方法和优化措施的基础。文中所采用的例子来自于《 HadoopinAc
【MapReduce篇06】MapReduce之MapJoin和ReduceJoin1
08-04
MapReduce之MapJoin和ReduceJoin MapReduce是一种分布式计算模型，广泛应用于大数据处理和分析领域。其中，Join操作是 MapReduce 中的一种基本操作，用于连接来自不同数据源的数据。今天，我们将讲解 MapReduce 之 ...
MapReduce--Join
qq_46893497的博客
12-04 575
1、SQL中的关联 多表关联：实现两张表之间数据的联系 订单表：订单id、商品id、订单价格 商品表：商品id、商品名称 需求：得到每个订单的订单信息以及对应的商品的名称 前提：两张表需要有联系商品id sql中多表关联方式 join：实现多张表之间列与列的关联 一般用于如果结果中出现了多张表的表，就用join实现 订单表：订单id、商品id、订单价格 商品表：商品id、商品名称 将两张表的列进行合并 订单id、商品id、订单价格、商品id、商品名称 select * from 订单表
mapreduce中的join
myloveprogrmming的博客
12-04 663
mapreduce常见的join:reduce端的join、map端的join、semi join?? 【1】reduce端的join 核心思想： 在map端将来源不同的数据或者有不同用处的数据打标机输出，以便reduce端能 够识别并进行连接关系查找。 适合场景：所有的表都是大表时（几乎所有业务都满足） 优点：解决业务范围较广 缺点：从map端传到reduce端的数据量较大。且有很多...
MapReduce-join连接
weixin_30629977的博客
09-22 167
join连接 MapReduce能够执行大型数据集间的连接（join）操作。连接操作的具体实现技术取决于数据集的规模及分区方式连接操作如果由mapper执行，则称为“map端连接”；如果由reducer执行，则称为“reduce端连接”。 Map端连接 在两个大规模输入数据集之间的map端连接会在数据到达map函数之前就执行连接操作。为达到该目的，各map的输入数据必须先分区并且以特定方式排...
MapReduce中的Join
a6a6a_6的博客
03-29 236
reduce side join : 在map 阶段，map 函数同时读取两个文件File1 和File2，为了区分 两种来源的key/value 数据对，对每条数据打一个标签（tag）,比如：tag=0 表示来自文件File1， tag=2 表示来自文件File2。 map side join : Map side join 是针对以下场景进行的优化：两个待连接表中，有一个表非常大，而另一个表非常小，以至于小表可以直接存放到内存中。这样，我们可以将小表复制多份，让...
MapReduce之join操作
happy19870612's blog
11-17 692
一  前言 在很多时候，我们可能需要处理的不是一个单独的文件，而是几个有关联的文件，比如账户信息和订单信息=> 账户信息：customerIdname address telephone 订单信息：orderIdcustomerId price productName 我们很可能就需要用到这2个文件，并且他们的关系通过用户id进行关联或者join.   两个文件的关联点作为key，后面
MapReduce Join 介绍
lv_hulk的博客
02-17 501
MapReduce Join 介绍 MapReduce 的 Join 操作主要分两类：MapJoin 和 ReduceJoin ReduceJoin: 1、 map 阶段，两份数据 data1 和 data2 会被 map 分别读入，解析成以链接字段为 key 以查询字段为 value 的 key-value 对，并标明数据来源是 data1 还是 data2。 2、 reduce 阶段，redu...
mapreduce之join
chunzhi0821的博客
04-25 208
实现思想：MR实现表的join操作，实际上是不同文件的join操作，不同文件通过某些列作为连接字段进行连接。 为了实现这一功能，过程如下： 1、在map阶段，将连接的字段组成map的key值（如连接字段有多个，可以将这些字段通过某个分隔符进行连接），将其他字段通过分隔符连接放在map的v...
MapReduce 实现 join
往者不可谏，来者犹可追
07-05 508
在reduce端实现两表的join reduce side join是一种最简单的join方式，其主要思想如下： 在map阶段，map函数同时读取两个文件File1和File2，为了区分两种来源的key/value数据对，对每条数据打一个标签（tag）,比如：tag=0表示来自文件File1，tag=2表示来自文件File2。即：map阶段的主要任务是对不同文件中的数据打标签。
Hadoop MapReduce Join操作详解
"MapReduce之Join操作" 在大数据处理领域，Hadoop MapReduce 是一种广泛使用的分布式计算框架。尽管关系型数据库中的Join操作已经被高度优化，但在处理海量数据时，使用MapReduce实现Join同样至关重要。本篇文章将...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值