使用MapReduce实现join操作

最新推荐文章于 2022-02-05 19:35:08 发布
最新推荐文章于 2022-02-05 19:35:08 发布
阅读量294 收藏 2
点赞数
文章标签： 大数据 java 开发工具
原文链接：http://www.cnblogs.com/hanganglin/p/4558510.html
版权

　  在关系型数据库中，要实现join操作是非常方便的，通过sql定义的join原语就可以实现。在hdfs存储的海量数据中，要实现join操作，可以通过HiveQL很方便地实现。不过HiveQL也是转化成MapReduce来完成操作，本文首先研究如何通过编写MapReduce程序来完成join操作。

一、Map-Join：在Reduce端完成的join操作

　  假设存在用户数据文件users.txt和用户登录日志数据文件login_logs.txt，数据内容分别如下所示：

　  用户数据文件user.txt，列：userid、name：

1    LiXiaolong
2    JetLi
3    Zhangsan
4    Lisi
5    Wangwu
View Code

　  用户登录日志数据文件login_logs.txt，列：userid、login_time、login_ip：

1    2015-06-07 15:10:18    192.168.137.101
3    2015-06-07 15:12:18    192.168.137.102
3    2015-06-07 15:18:36    192.168.137.102
1    2015-06-07 15:22:38    192.168.137.101
1    2015-06-07 15:26:11    192.168.137.103
View Code

　  期望计算结果：

1    LiXiaolong    2015-06-07 15:10:18    192.168.137.101
1    LiXiaolong    2015-06-07 15:22:38    192.168.137.101
1    LiXiaolong    2015-06-07 15:26:11    192.168.137.103
3    Zhangsan    2015-06-07 15:12:18    192.168.137.102
3    Zhangsan    2015-06-07 15:18:36    192.168.137.102
View Code

　  计算思路：

　  1) 在map阶段可以通过文件路径判断来自users.txt还是login_logs.txt，来自users.txt的数据输出<userid, 'u#'+name>，来自login_logs.txt的数据输出<userid,'l#'+login_time+'\t'+login_ip>；

　  2) 在reduce阶段将来自不同表的数据区分开，然后做笛卡尔乘积，输出结果；

　  实现代码：

package com.hicoor.hadoop.mapreduce;

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

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.input.FileSplit;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

public class ReduceJoinDemo {
    public static final String DELIMITER = "\t"; // 字段分隔符

    static class MyMappper 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 split = (FileSplit) context.getInputSplit();
            String filePath = split.getPath().toString();
            // 获取记录字符串
            String line = value.toString();
            // 抛弃空记录
            if (line == null || line.trim().equals("")) return;

            String[] values = line.split(DELIMITER);
            // 处理user.txt数据
            if (filePath.contains("users.txt")) {
                if (values.length < 2) return;
                context.write(new Text(values[0]), new Text("u#" + values[1]));
            }
            // 处理login_logs.txt数据
            else if (filePath.contains("login_logs.txt")) {
                if (values.length < 3) return;
                context.write(new Text(values[0]), new Text("l#" + values[1] + DELIMITER + values[2]));
            }
        }
    }

    static class MyReducer 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 {

            LinkedList<String> linkU = new LinkedList<String>();  //users值
            LinkedList<String> linkL = new LinkedList<String>();  //login_logs值
              
            for (Text tval : values) {
                String val = tval.toString();  
                if(val.startsWith("u#")) {
                    linkU.add(val.substring(2));
                } else if(val.startsWith("l#")) {
                    linkL.add(val.substring(2));
                }
            }
              
            for (String u : linkU) {
                for (String l : linkL) {
                    context.write(key, new Text(u + DELIMITER + l));
                }
            }
        }
    }

    private final static String FILE_IN_PATH = "hdfs://cluster1/join/in";
    private final static String FILE_OUT_PATH = "hdfs://cluster1/join/out";

    public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException, URISyntaxException {
        System.setProperty("hadoop.home.dir", "D:\\desktop\\hadoop-2.6.0");
        Configuration conf = getHAContiguration();

        // 删除已存在的输出目录
        FileSystem fileSystem = FileSystem.get(new URI(FILE_OUT_PATH), conf);
        if (fileSystem.exists(new Path(FILE_OUT_PATH))) {
            fileSystem.delete(new Path(FILE_OUT_PATH), true);
        }

        Job job = Job.getInstance(conf, "Reduce Join Demo");
        job.setMapperClass(MyMappper.class);
        job.setJarByClass(ReduceJoinDemo.class);
        job.setReducerClass(MyReducer.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(Text.class);
        FileInputFormat.addInputPath(job, new Path(FILE_IN_PATH));
        FileOutputFormat.setOutputPath(job, new Path(FILE_OUT_PATH));
        job.waitForCompletion(true);
    }

    private static Configuration getHAContiguration() {
        Configuration conf = new Configuration();
        conf.setStrings("dfs.nameservices", "cluster1");
        conf.setStrings("dfs.ha.namenodes.cluster1", "hadoop1,hadoop2");
        conf.setStrings("dfs.namenode.rpc-address.cluster1.hadoop1", "172.19.7.31:9000");
        conf.setStrings("dfs.namenode.rpc-address.cluster1.hadoop2", "172.19.7.32:9000");
        // 必须配置，可以通过该类获取当前处于active状态的namenode
        conf.setStrings("dfs.client.failover.proxy.provider.cluster1", "org.apache.hadoop.hdfs.server.namenode.ha.ConfiguredFailoverProxyProvider");
        return conf;
    }

}
View Code
二、Reduce-join：在Reduce端完成的join操作

 　  当join的两个表中有一个表数据量不大，可以轻松加载到各节点内存中时，可以使用DistributedCache将小表的数据加载到分布式缓存，然后MapReduce框架会缓存数据分发到需要执行map任务的节点上，在map节点上直接调用本地的缓存文件参与计算。在Map端完成join操作，可以降低网络传输到Reduce端的数据流量，有利于提高整个作业的执行效率。

　  计算思路：

　  假设users.txt用户表数据量较小，则将users.txt数据添加到DistributedCache分布式缓存中，在map计算中读取本地缓存的users.txt数据并将login_logs.txt中的userid数据翻译成用户名，本例无需Reduce参与。

　  实现代码：

package com.hicoor.hadoop.mapreduce;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.Map;
import java.util.Scanner;
import java.util.StringTokenizer;

import org.apache.commons.collections.map.HashedMap;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.examples.SecondarySort.Reduce;
import org.apache.hadoop.fs.FSDataInputStream;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.filecache.DistributedCache;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.yarn.webapp.example.MyApp.MyController;

public class DistributedCacheDemo {
    public static final String DELIMITER = "\t"; // 字段分隔符

    static class MyMappper extends Mapper<LongWritable, Text, Text, Text> {
        private Map<String, String> userMaps = new HashedMap();
        
        @Override
        protected void setup(Mapper<LongWritable,Text,Text,Text>.Context context) throws IOException ,InterruptedException {
            //可以通过localCacheFiles获取本地缓存文件的路径
            //Configuration conf = context.getConfiguration();
            //Path[] localCacheFiles = DistributedCache.getLocalCacheFiles(conf);
            
            //此处使用快捷方式users.txt访问
            FileReader fr = new FileReader("users.txt");
            BufferedReader br = new BufferedReader(fr);
            String line;
            while((line = br.readLine()) != null) {
                //map端加载缓存数据
                String[] splits = line.split(DELIMITER);
                if(splits.length < 2) continue;
                userMaps.put(splits[0], splits[1]);
            }
        };
        
        @Override
        protected void map(LongWritable key, Text value, Mapper<LongWritable, Text, Text, Text>.Context context) throws IOException, InterruptedException {
            // 获取记录字符串
            String line = value.toString();
            // 抛弃空记录
            if (line == null || line.trim().equals("")) return;
            
            String[] values = line.split(DELIMITER);
            if(values.length < 3) return;
            
            String name = userMaps.get(values[0]);
            Text t_key = new Text(values[0]);
            Text t_value = new Text(name + DELIMITER + values[1] + DELIMITER + values[2]);
            context.write(t_key, t_value);
        }
    }

    private final static String FILE_IN_PATH = "hdfs://cluster1/join/in/login_logs.txt";
    private final static String FILE_OUT_PATH = "hdfs://cluster1/join/out";

    public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException, URISyntaxException {
        System.setProperty("hadoop.home.dir", "D:\\desktop\\hadoop-2.6.0");
        Configuration conf = getHAConfiguration();

        // 删除已存在的输出目录
        FileSystem fileSystem = FileSystem.get(new URI(FILE_OUT_PATH), conf);
        if (fileSystem.exists(new Path(FILE_OUT_PATH))) {
            fileSystem.delete(new Path(FILE_OUT_PATH), true);
        }

        //添加分布式缓存文件 可以在map或reduce中直接通过users.txt链接访问对应缓存文件
        DistributedCache.addCacheFile(new URI("hdfs://cluster1/join/in/users.txt#users.txt"), conf);
        
        Job job = Job.getInstance(conf, "Map Distributed Cache Demo");
        job.setMapperClass(MyMappper.class);
        job.setJarByClass(DistributedCacheDemo.class);
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(Text.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(Text.class);
        FileInputFormat.addInputPath(job, new Path(FILE_IN_PATH));
        FileOutputFormat.setOutputPath(job, new Path(FILE_OUT_PATH));
        job.waitForCompletion(true);
    }

    private static Configuration getHAConfiguration() {
        Configuration conf = new Configuration();
        conf.setStrings("dfs.nameservices", "cluster1");
        conf.setStrings("dfs.ha.namenodes.cluster1", "hadoop1,hadoop2");
        conf.setStrings("dfs.namenode.rpc-address.cluster1.hadoop1", "172.19.7.31:9000");
        conf.setStrings("dfs.namenode.rpc-address.cluster1.hadoop2", "172.19.7.32:9000");
        //必须配置，可以通过该类获取当前处于active状态的namenode
        conf.setStrings("dfs.client.failover.proxy.provider.cluster1", "org.apache.hadoop.hdfs.server.namenode.ha.ConfiguredFailoverProxyProvider");
        return conf;
    }

}
View Code
三、使用HiveQL来完成join

　  使用HiveQL可以轻松完成该任务，只需使用表连接语句，hive会自动生成并优化mapreduce程序来执行查询操作。

　  实现步骤：

　  1) 在/join/in/目录下创建users目录和login_logs目录，分别将users.txt和login_logs.txt移动到对应目录中；

　  2) 创建users外部表：create external table users(userid int, name string) row format delimited fields terminated by '\t' location '/join/in/users';

　  3) 创建login_logs外部表：create external table login_logs(userid string,login_time string,login_ip string) row format delimited fields terminated by '\t' location '/join/in/login_logs';

　  4）执行连接查询并保存结果：create table user_login_logs as select A.*,B.login_time,B.login_ip from users A,login_logs B where A.userid=B.userid;

四、总结

 　  通常情况下我们会使用hive来帮助我们完成join操作，map-join和reduce-join用于实现一些复杂的、特殊的需求。此外还有一种实现方式：SemiJoin，这是一种介于map-join和reduce-join之间的方法，就是在map端过滤掉一些数据，在网络中只传输参与连接的数据不参与连接的数据不必在网络中进行传输，从而减少了shuffle的网络传输量，使整体效率得到提高。

　  执行效率：map-join>SemiJoin>reduce-join。

　  参考：http://database.51cto.com/art/201410/454277.htm

转载于:https://www.cnblogs.com/hanganglin/p/4558510.html

weixin_34245749
关注
MapReduce之Map阶段的join操作案例
QYHuiiQ
06-08 392
在这个案例中我们要实现的是Map端的join，通常情况下我们会将小表放在分布式缓存中，然后将大表通过正常的map阶段与小表进行join，得到一个join之后的结果，这样map之后的结果就是我们想要的结果，那么就不需要reduce了，所以在该案例中，我们只需要自定义Mapper和主类即可。沿用上一个案例中的两个表，我们把学生基本信息表作为小表，把成绩表作为大表。先将数据文件放入HDFS中： 我们需要在程序启动时就将小表的数据文件放入分布式缓存中，这一步骤需要在主类中配置才能实现。新建project：
使用mapreduce实现多表连接join操作
sherry2233的博客
06-05 2383
（1） 准备小的数据测试集  输入是两个文件，一个代表工厂表，包含工厂名列和地址编号列；另一个代表地址表，包含地址名列和地址编号列。要求从输入数据中找出工厂名和地址名的对应关系，输出"地址编号——地址名——工厂名"表。 工厂表    地址表 结果输出如下： （2）设计思路    多表关联和单表关联相似，都类似于数据库中的自然连接。相比单表关联，多表关联的左右表和连接列
MapReduce实现join连接
08-30
简单的在MapReduce中实现两个表的join连接简单的在MapReduce中实现两个表的join连接简单的在MapReduce中实现两个表的join连接
MapReduce 实现数据join操作
dingmu2707的博客
05-03 268
前段时间有一个业务需求，要在外网商品（TOPB2C）信息中加入联营自营识别的字段。但存在的一个问题是，商品信息和自营联营标示数据是两份数据；商品信息较大，是存放在hbase中。他们之前唯一的关联是url。所以考虑用url做key将两者做join，将联营自营标识信息加入的商品信息中，最终生成我需要的数据； 一，首先展示一下两份数据的demo example 1. 自...
MapReduce中的Join算法
努力的凹凸曼的博客
05-09 515
       在关系型数据库中 Join 是非常常见的操作，各种优化手段已经到了极致。在海量数据的环境下，不可避免的也会碰到这种类型的需求， 例如在数据分析时需要连接从不同的数据源中获取到数据。不同于传统的单机模式，在分布式存储下采用MapReduce 编程模型，也有相应的处理措施和优化方法。       现在假设有两个数据集：气象站数据库和天气记录数据库，并考虑如何合二为一。一个典型的查询是：输...
Join在MapReduce中的实现
zhaoxiaoba123的博客
09-12 313
1、ReduceJoin流程分析 数据通过Mapper加载过来，然后经过shuffle阶段，在Reduce端完成真正的Join操作 2、ReduceJion功能的实现 Mapjoin实现原理 有些数据比较小，是否有必要经过shuffle,shufflt是大数据中最耗时最耗资源的，能规避shuffle就规避shuffle,也就是说是没有reduce的 Mapjoin功能实现 ...
MapReduce实现join操作
热门推荐
葱葱的城堡
05-30 2万+
前阵子把MapReduce实现join操作的算法设想清楚了，但一直没有在代码层面落地。今天终于费了些功夫把整个流程走了一遭，期间经历了诸多麻烦并最终得以将其一一搞定，再次深切体会到，什么叫从计算模型到算法实现还有很多路要走。 数据准备 首先是准备好数据。这个倒已经是一个熟练的过程，所要做的是把示例数据准备好，记住路径和字段分隔符。 准备好下面两张表： （1）m_ys_lab
MapReduce之Join操作
03-03
在关系型数据库中join是非常常见的操作，各种优化手段已经到了极致。在海量数据的环境下，不可避免的也会碰到这种类型的需求，例如在数据分析时需要连接从不同的数据源中获取到的数据。不同于传统的单机模式，在...
MapReduce Join操作
qq_40759271的博客
01-30 390
Mapreduce连接 1、reduce side join 在reduce端进行表的连接，该方法的特点就是操作简单，缺点是map端shffule后传递给reduce端的数据量过大，极大的降低了性能 连接方法： （1）map端读入输入数据，以连接键为Key，待连接的内容为value，但是value需要添加特别的标识，表示的内容为表的表示，即若value来自于表1，则标识位设置为1，若来
MapReduce之Join操作(1)
天光云影
03-14 117
在关系型数据库中 join 是非常常见的操作，各种优化手段已经到了极致。在海量数据的环境下，不可避免的也会碰到这种类型的需求，例如在数据分析时需要连接从不同的数据源中获取到的数据。不同于传统的单机模式，在分布式存储的下采用 MapReduce 编程模型，也有相应的处理措施和优化方法。 本文对 H...
MapReduce编程-join算法实现
成都往右的博客
10-13 659
假设有订单表t_order和t_product两张数据库表，现在需要进行关联查询。这样的sql语句很容易写select a.id,a.date,b.name,b.category_id,b.price from t_order a left out join t_product b on a.pid = b.id那么怎么样用mapreduce来实现呢？
MapReduce：实现join的几种方法
sofuzi的博客
07-28 1万+
reduce side join reduce side join是一种最简单的join方式，其主要思想如下：  在map阶段，map函数同时读取两个文件File1和File2，为了区分两种来源的key/value数据对，对每条数据打一个标签&gt; （tag）,比如：tag=0表示来自文件File1，tag=2表示来自文件File2。即：map阶段的主要任务是对不同文件中的数据打标签。&gt...
基于mapreduce的Hadoop join实现
和大黄的博客
11-03 5169
对于一个大数据的分析应用,join是必不可少的一项功能.现在很多构建与hadoop之上的应用,如Hive,PIG等在其内部实现了join程序,可以通过很简单的sql语句或者数据操控脚本完成相应的Join工作.那么join应该如何实现呢?今天我们就对join做一个简单的实现. 我们来看一个例子,现在有两组数据:一组为单位人员信息,如下: 人员ID 人员名称 地址ID 1 张三 1 2 李
Hadoop生态圈（二十五）- MapReduce Join操作
程序园@大Null
02-05 2116
MapReduce分布式缓存，reduce side join概述，map side join概述，MapReduce join案例：订单商品处理，reduce side join弊端，map side join优势
MapReduce实现Reduce端Join操作实例
吃果冻不吐果冻皮
06-15 2640
使用案例： 联接两张表 Table EMP：（新建文件EMP，第一行属性名不要） Name Sex Age DepNo zhang male 20 1 li female 25 2 wang female 30 3 zhou
Mapreduce学习（6）——join操作
qq_32695789的博客
03-03 282
在mapreduce程序中有可能遇到文件一种某个字段对应另外一个文件中的某个字段我们又想把这两个文件中的数据在一起展示 例如文件一： 第一列代表订单号、第二列代表商品ID、第三列代表商品卖出数量 文件二： 第一列代表商品ID、第二列代表商品名、第三列代表商品单价 情景：求出每个订单商品总价（商品单价*数量的和） 解决：将两个文件进行join操作 准备文件： 把订单文件和商品...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值