Hadoop中Join多种应用

最新推荐文章于 2022-03-16 17:22:54 发布
最新推荐文章于 2022-03-16 17:22:54 发布
阅读量566 收藏 3
点赞数 1
分类专栏： 大数据 Hadoop 文章标签： Join操作 mapreduce

今天，南国在网上看到一篇不错的文章总结，也是我之前没有深入学习的一个知识点。在这里，对知识点做一个简要的概括和案例分析。

总结：

Join： 将两个中的字段，通过公共字段进行关联！
MR ：
①在Reduce端Join
1.保证两个文件中的所有字段，都必须达到Reduce!需要将两个文件的所有字段封装为一个Bean
2.在Map端，为每个文件，打上标记
弊端：如果数据量大，reduce端处理过程耗时！
②在Map端Join
1.将大文件，作为输入文件，通过输入格式读入到MapTask
2.小文件，使用分布式缓存，在进入Mapper时，提前从缓存中读取小文件中的内容
缓存文件： job.addCacheFile()
读取缓存： jod.getCacheFiles()

1 Reduce Join

在这里插入图片描述

2 Reduce Join案例操作

1．需求

表订单数据表t_order

idpidamount
1001011
1002022
1003033
1004014
1005025
1006036

表商品信息表t_product

pidpname
01小米
02华为
03三星

将商品信息表中数据根据商品pid合并到订单数据表中。
表最终数据形式

idpnameamount
1001小米1
1004小米4
1002华为2
1005华为5
1003三星3
1006三星6

2．需求分析

通过将关联条件作为Map输出的key，将两表满足Join条件的数据并携带数据所来源的文件信息，发往同一个ReduceTask，在Reduce中进行数据的串联，如图所示。
在这里插入图片描述
图 Reduce端表合并

3．代码实现

1）创建商品和订合并后的Bean类

package com.demo.mapreduce.table;
import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
import org.apache.hadoop.io.Writable;
public class TableBean implements Writable {
    private String order_id; // 订单id
    private String p_id;      // 产品id
    private int amount;       // 产品数量
    private String pname;     // 产品名称
    private String flag;      // 表的标记
    public TableBean() {
       super();
    }
    public TableBean(String order_id, String p_id, int amount, String pname, String flag) {
       super();
       this.order_id = order_id;
       this.p_id = p_id;
       this.amount = amount;
       this.pname = pname;
       this.flag = flag;
    }
    public String getFlag() {
       return flag;
    }
    public void setFlag(String flag) {
       this.flag = flag;
    }
    public String getOrder_id() {
       return order_id;
    }
    public void setOrder_id(String order_id) {
       this.order_id = order_id;
    }
    public String getP_id() {
       return p_id;
    }
    public void setP_id(String p_id) {
       this.p_id = p_id;
    }
    public int getAmount() {
       return amount;
    }
    public void setAmount(int amount) {
       this.amount = amount;
    }
    public String getPname() {
       return pname;
    }
    public void setPname(String pname) {
       this.pname = pname;
    }
    @Override
    public void write(DataOutput out) throws IOException {
       out.writeUTF(order_id);
       out.writeUTF(p_id);
       out.writeInt(amount);
       out.writeUTF(pname);
       out.writeUTF(flag);
    }
    @Override
    public void readFields(DataInput in) throws IOException {
       this.order_id = in.readUTF();
       this.p_id = in.readUTF();
       this.amount = in.readInt();
       this.pname = in.readUTF();
       this.flag = in.readUTF();
    }
    @Override
    public String toString() {
       return order_id + "\t" + pname + "\t" + amount + "\t" ;
    }
}

2）编写TableMapper类

package com.demo.mapreduce.table;
import java.io.IOException;
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;

public class TableMapper extends Mapper<LongWritable, Text, Text, TableBean>{
    String name;
    TableBean bean = new TableBean();
    Text k = new Text();
    
    @Override
    protected void setup(Context context) throws IOException, InterruptedException {
       // 1 获取输入文件切片
       FileSplit split = (FileSplit) context.getInputSplit();
       // 2 获取输入文件名称
       name = split.getPath().getName();
      }

    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
       // 1 获取输入数据
       String line = value.toString();
       // 2 不同文件分别处理
       if (name.startsWith("order")) {// 订单表处理
           // 2.1 切割
           String[] fields = line.split("\t");      
           // 2.2 封装bean对象
           bean.setOrder_id(fields[0]);
           bean.setP_id(fields[1]);
           bean.setAmount(Integer.parseInt(fields[2]));
           bean.setPname("");
           bean.setFlag("order");    
           k.set(fields[1]);
       }else {// 产品表处理
           // 2.3 切割
           String[] fields = line.split("\t");     
           // 2.4 封装bean对象
           bean.setP_id(fields[0]);
           bean.setPname(fields[1]);
           bean.setFlag("pd");
           bean.setAmount(0);
           bean.setOrder_id("");
           k.set(fields[0]);
       }
       // 3 写出
       context.write(k, bean);
    }
}

3）编写TableReducer类

package com.demo.mapreduce.table;
import java.io.IOException;
import java.util.ArrayList;
import org.apache.commons.beanutils.BeanUtils;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

public class TableReducer extends Reducer<Text, TableBean, TableBean, NullWritable> {

    @Override
    protected void reduce(Text key, Iterable<TableBean> values, Context context)  throws IOException, InterruptedException {
       // 1准备存储订单的集合
       ArrayList<TableBean> orderBeans = new ArrayList<>();    
		// 2 准备bean对象
       TableBean pdBean = new TableBean();
       for (TableBean bean : values) {
           if ("order".equals(bean.getFlag())) {// 订单表
              // 拷贝传递过来的每条订单数据到集合中
              TableBean orderBean = new TableBean();
              try {
                  BeanUtils.copyProperties(orderBean, bean);
              } catch (Exception e) {
                  e.printStackTrace();
              }
              orderBeans.add(orderBean);
           } else {// 产品表
              try {
                  // 拷贝传递过来的产品表到内存中
                  BeanUtils.copyProperties(pdBean, bean);
              } catch (Exception e) {
                  e.printStackTrace();
              }
           }
       }
       // 3 表的拼接
       for(TableBean bean:orderBeans){
           bean.setPname (pdBean.getPname());
           // 4 数据写出去
           context.write(bean, NullWritable.get());
       }
    }
}

4）编写TableDriver类

package com.demo.mapreduce.table;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.NullWritable;
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; 

public class TableDriver {
    public static void main(String[] args) throws Exception {
	// 0 根据自己电脑路径重新配置
	args = new String[]{"e:/input/inputtable","e:/output1"};
	// 1 获取配置信息，或者job对象实例
     Configuration configuration = new Configuration();
     Job job = Job.getInstance(configuration);
     // 2 指定本程序的jar包所在的本地路径
     job.setJarByClass(TableDriver.class);
     // 3 指定本业务job要使用的Mapper/Reducer业务类
      job.setMapperClass(TableMapper.class);
      job.setReducerClass(TableReducer.class);
      // 4 指定Mapper输出数据的kv类型
      job.setMapOutputKeyClass(Text.class);
      job.setMapOutputValueClass(TableBean.class);
      // 5 指定最终输出的数据的kv类型
      job.setOutputKeyClass(TableBean.class);
      job.setOutputValueClass(NullWritable.class);
     // 6 指定job的输入原始文件所在目录
     FileInputFormat.setInputPaths(job, new Path(args[0]));
     FileOutputFormat.setOutputPath(job, new Path(args[1]));
     // 7 将job中配置的相关参数，以及job所用的java类所在的jar包， 提交给yarn去运行
     boolean result = job.waitForCompletion(true);
     System.exit(result ? 0 : 1);
    }
}

4．测试

运行程序查看结果

1001   小米    1  
1001   小米    1  
1002   华为    2  
1002   华为    2  
1003   格力    3  
1003   格力    3

总结

缺点：这种方式中，合并的操作是在Reduce阶段完成，Reduce端的处理压力太大，Map节点的运算负载则很低，资源利用率不高，且在Reduce阶段极易产生数据倾斜。

解决方案：在Map端实现数据合并

3 Map Join

1.使用场景

Map Join适用于一张小表 一张大表的场景

2.优点

在Rduce端处理太多的表，非常容易产生数据倾斜。如何解决了？？
在Map端缓存多张表，提前处理业务逻辑，这样增加Map端业务，减少Reduce端的压力，尽可能的减少数据倾斜。

3.具体办法：采用DistributedCache

(1) 在Mapper的setup阶段，将文件读取到缓存集合中。
(2) 在驱动函数中加载缓存
//缓存普通文件到Task运行节点
job.addCacheFile(new URI(“file://e:/cache/pd.txt”));

4.Map Join案例操作

依旧使用上面那个案例，将商品信息表中数据根据商品pid合并到订单数据表中。
表最终数据形式

idpnameamount
1001小米1
1004小米4
1002华为2
1005华为5
1003三星3
1006三星6
需求分析

MapJoin适用于关联几个表中有小表的情形
在这里插入图片描述

实现代码

(1)在驱动模块中添加缓存文件

package test;
import java.net.URI;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.NullWritable;
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;

public class DistributedCacheDriver {
    public static void main(String[] args) throws Exception {
		// 0 根据自己电脑路径重新配置
		args = new String[]{"e:/input/inputtable2", "e:/output1"};
		// 1 获取job信息
       Configuration configuration = new Configuration();
       Job job = Job.getInstance(configuration);
       // 2 设置加载jar包路径
       job.setJarByClass(DistributedCacheDriver.class);
       // 3 关联map
       job.setMapperClass(DistributedCacheMapper.class);  
		// 4 设置最终输出数据类型
       job.setOutputKeyClass(Text.class);
       job.setOutputValueClass(NullWritable.class);
       // 5 设置输入输出路径
       FileInputFormat.setInputPaths(job, new Path(args[0]));
       FileOutputFormat.setOutputPath(job, new Path(args[1]));
       // 6 加载缓存数据
       job.addCacheFile(new URI("file:///e:/input/inputcache/pd.txt"));
       // 7 Map端Join的逻辑不需要Reduce阶段，设置reduceTask数量为0
       job.setNumReduceTasks(0);
       // 8 提交
       boolean result = job.waitForCompletion(true);
       System.exit(result ? 0 : 1);
    }
}

(2)读取缓存的文件的文件数据

package test;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.Map;
import org.apache.commons.lang.StringUtils;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper; 

public class DistributedCacheMapper extends Mapper<LongWritable, Text, Text, NullWritable>{
    Map<String, String> pdMap = new HashMap<>(); 

    @Override
    protected void setup(Mapper<LongWritable, Text, Text, NullWritable>.Context context) throws IOException, InterruptedException {
       // 1 获取缓存的文件
       URI[] cacheFiles = context.getCacheFiles();
       String path = cacheFiles[0].getPath().toString();
       BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(path), "UTF-8"));
       String line;       
       while(StringUtils.isNotEmpty(line = reader.readLine())){
           // 2 切割
           String[] fields = line.split("\t");
           // 3 缓存数据到集合
           pdMap.put(fields[0], fields[1]);
       }
       // 4 关流
       reader.close();
      }
    Text k = new Text();
    
    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
       // 1 获取一行
       String line = value.toString();
       // 2 截取
       String[] fields = line.split("\t"); 
       // 3 获取产品id
       String pId = fields[1];    
       // 4 获取商品名称
       String pdName = pdMap.get(pId);
       // 5 拼接
       k.set(line + "\t"+ pdName);
       // 6 写出
       context.write(k, NullWritable.get());
    }
}

文章原文来自：https://blog.csdn.net/qq_43193797/article/details/86139847

提灯寻梦在南国
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
hive中Mapjoin 和Reducejoin 的区别
qq_41704237的博客
07-12 1838
Map join 配置： set hive.auto.convert.join = true（0.11版本后默认是true） set hive.mapjoin.smalltable.filesize=25000000（设置小表的大小，默认就是25M） 原理： mapjoin ：主要用于小表连接大表，一般小表的大小为25M，大表没有什么具体的限制。 使用mapjoin的原因是： 在进行表的连接时，在map端处理完数据后，会把不同表的数据，形成不同的文件，reduce端进行拉取map端获得文件时，由于map端文
MapJoin和ReduceJoin区别及优化
热门推荐
谦蓦的博客
11-18 1万+
MapJoin和ReduceJoin区别Map-side Join（Broadcast join）思想： 小表复制到各个节点上，并加载到内存中；大表分片，与小表完成连接操作。 两份数据中，如果有一份数据比较小，小数据全部加载到内存，按关键字建立索引。大数据文件作为map的输入，对map()函数每一对输入，都能够方便的和已加载到内存的小数据进行连接。把连接结果按key输出，经过shuffle阶段，
map端做join和reduce端做join有何区别？
mark_to_win的专栏
05-24 1015
马克-to-win @ 马克java社区：map 端做join和reduce端做join有何区别？我们前面讲的是Reduce端join，因为Reduce端join需要把所有的数据都经过 Shuffle，非常消耗资源，效率要远远低于Map端join。Map端join是指只有map工作，reduce不工作，这样可以有效的避免数据倾 斜。 更多请见：https://blog.csdn.net/qq_4...
map端join和reduce端join的区别
weixin_30780221的博客
06-03 812
MapReduce Join MapJoin和ReduceJoin区别及优化 maptask处理后写到本地，如果再到reduce，又涉及到网络的拷贝。 map端join最大优势，可以提前过滤不需要的数据。 如对于20G左右的文件，可以用2个job来处理： 一个mapreduce进行数据过滤， 另一个mapreduce进行计算。 转载于:https://www.cnblogs.com/p...
Map Join和Reduce Join的区别以及代码实现
qq_31337471的博客
08-28 4712
MapReduce Join 对两份数据data1和data2进行关键词连接是一个很通用的问题，如果数据量比较小，可以在内存中完成连接。 如果数据量比较大，在内存进行连接操会发生OOM。mapreduce join可以用来解决大数据的连接。 1 思路 1.1 reduce join 在map阶段, 把关键字作为key输出，并在value中标记出数据是来自data1还是data2。因为...
hadoop_join.jar.zip_hadoop_hadoop query_reduce
09-20
在大数据处理领域，Hadoop和MapReduce是两个至关重要的概念，它们构成了大数据处理的基础框架。本文将深入探讨如何使用Hadoop和...在实际应用中，需要根据数据规模、数据分布以及特定业务需求来选择最合适的Join方法。
hadoop Join代码（map join 和reduce join）
12-10
Map JOIN在Hadoop中主要应用于小表与大表的连接。小表的数据可以完全加载到内存中，而大表则按块分发到各个Mapper。当Mapper处理大表时，它会检查小表是否已经加载到内存，如果找到匹配项，则进行连接操作。这种...
Hadoop技术-Pig简介.pptx
11-02
Pig是Hadoop生态系统中的一个高级数据处理工具，主要设计用于大数据集的分析。它的核心思想是简化大数据分析任务，通过提供一种名为Pig Latin的高级编程语言，让数据分析师和程序员能够方便地进行数据处理，而无需...
Hadoop大数据技术-pig操作
最新发布
06-04
在大数据处理领域，Hadoop是一个不可或缺的开源框架，它提供了分布式存储和计算的能力，使得海量数据的处理变得可能。...在实际应用中，理解并熟练掌握Pig的各种操作对于提升大数据处理能力至关重要。
Hadoop技术Hive简介共9页.pdf.zip
11-21
这篇名为“Hadoop技术Hive简介共9页”的资料，很显然会涵盖Hive的基本概念、架构、功能以及在大数据分析中的应用。 Hive是由Facebook开发并开源的，其设计目标是为了简化对PB级别数据的查询和管理。Hive的核心理念...
Hadoop的Map侧join
tianshidcbw的博客
06-17 406
写了关于Hadoop的Map侧join  和Reduce的join，今天我们就来在看另外一种比较中立的Join。  SemiJoin，一般称为半链接，其原理是在Map侧过滤掉了一些不需要join的数据，从而大大减少了reduce的shffule时间，因为我们知道，如果仅仅使用Reduce侧连接，那么如果一份数据中，存在大量的无效数据，而这些数据，在join中，并不需要，但是因为没有做过预处
Hadoop MR 之(六) Join操作 (MapJoin & ReduceJon & 缓存)
Be yourself.
04-06 561
前言 在前面的几章内, 我们主要讲解了如何进行简单的MR操作, 以及如何开发自定义组件.(Combiner/InputFormat等). 在本章中, 我们主要讲解MR中的一个非常经典的问题: 如何实现Join操作? 本文相关代码, 可在我的Github项目 https://github.com/SeanYanxml/bigdata/ 目录下可以找到. PS: (如果觉得项目不错, 可以给我一个St...
Hadoop——MapJoin（减少数据倾斜）
d_l_w_d_l_w的博客
09-07 278
首先，先说一下当前了解到的一个适用MapJoin的场景吧： 比如我们此时手中有两个表需要我们进行处理，但是呢一个很大，一个很小。那么这个时候我们比较适合使用MapJoin进行处理。 那么我们具体是怎么实现MapJoin的这个操作的呢？： 我们可以在map端对小的那个表先进行缓存，提前在map端将数据进行处理，那么这么做有什么好处呢，我们可以减少reduce端的压力、加快数据传输的速度、尽可能的减少reduce端出现数据倾斜（暂时个人理解为：因为每个map端的大小是可以设置的默认是128M，在map端进
hadoop基础【MapJoin、数据清洗和计数器，从windows向Yarn提交源码】
weixin_43923463的博客
03-16 1725
一、MapJoin ReduceJoin缺陷：在Reduce端处理过多的表，非常容易造成数据倾斜（在分区时数据划分的不均匀，导致其中一个并行的reduce处理的数据远远大于其他reduce处理的数据），导致运行效率过低。 MapJoin使用的情况：一张表十分小，一张表十分大。 优点：不会造成数据倾斜，造成数据倾斜的地方是在Shuffle分区的位置；没有Shuffle阶段，所以快，因为Shuffle会对数据进行全排序。 如何做：MapJoin将一张小表完全缓存进内存，在内存中用一个索引连接起来，用Ma
MapReduce编程之Reduce Join多种应用场景与使用
weixin_30877227的博客
08-13 225
在关系型数据库中 Join 是非常常见的操作，各种优化手段已经到了极致。在海量数据的环境下，不可避免的也会碰到这种类型的需求， 例如在数据分析时需要连接从不同的数据源中获取到数据。不同于传统的单机模式，在分布式存储下采用 MapReduce 编程模型，也有相应的处理措施和优化方法。 我们先简要地描述待解决的问题。假设有两个数据集：气象站数据库和天气记录数据库，并考虑如何合二为一。一个典型的查询是...
用MR实现Join逻辑的两种方法
yangzheng'Blog
09-18 5809
需求订单数据表 order.txt id date pid amount 1001 20150710 P0001 2 1002 20150710 P0001 3 1002 20150710 P0001 3 商品信息表 product.txt id pname category_id price P0001 小米5
hadoop案例：Mapjoin
张国荣家的弟弟
11-03 822
文章目录pom.xml输入数据期望结果需求分析Mapper类Reducer类Driver类执行结果 pom.xml <groupId>com.huang</groupId> <artifactId>Hadoop</artifactId> <version>1.0-SNAPSHOT</version> <build> <plugins> <plu
Reduce端join弊端&方法key探讨
dingqiu6346的博客
09-14 231
转载于:https://www.cnblogs.com/TiePiHeTao/p/fe9b73346f72255aee178385e3aae9a4.html
Hadoop Hive性能优化深度解析
创作，遵循 Creative Commons Attribution-ShareAlike 3.0 Unported 许可协议，内容涵盖Hive在大数据处理中的应用、Hive架构、性能优化、数据输入输出、安全性和Project Stinger等。” 在大数据处理领域，Hive作为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值