Join多种应用

最新推荐文章于 2023-10-18 11:33:23 发布
最新推荐文章于 2023-10-18 11:33:23 发布
阅读量224 收藏 1
点赞数
分类专栏： hadoop技术【初学】
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39868387/article/details/103328031
版权

Reduce Join

Reduce Join工作原理

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

Reduce Join案例实操

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
创建创建完毕：
在这里插入图片描述

第一步，对pom.xml文件依赖：

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.study</groupId>
    <artifactId>join1205</artifactId>
    <version>1.0-SNAPSHOT</version>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>8</source>
                    <target>8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>


    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
            <version>2.8.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-common</artifactId>
            <version>2.7.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-client</artifactId>
            <version>2.7.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-hdfs</artifactId>
            <version>2.7.2</version>
        </dependency>
        <dependency>
            <groupId>jdk.tools</groupId>
            <artifactId>jdk.tools</artifactId>
            <version>1.8</version>
            <scope>system</scope>
            <systemPath>${JAVA_HOME}/lib/tools.jar</systemPath>
        </dependency>
    </dependencies>
</project>

接着，java目录文件下创建com.study.reducejoin包、并在该包下创建类：RJComparator、RJMapper、RJReducer、RJDriver
在这里插入图片描述
并创建bean包与类
在这里插入图片描述

OrderBean.java

package com.study.bean;

import org.apache.hadoop.io.WritableComparable;

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

public class OrderBean implements WritableComparable<OrderBean> {
    private String id;
    private String pid;
    private int amount;
    private String pname;

    @Override
    public String toString() {
        return id + "\t" + pname + "\t" + amount;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getPid() {
        return pid;
    }

    public void setPid(String pid) {
        this.pid = pid;
    }

    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 int compareTo(OrderBean o) {
        int compare = this.pid.compareTo(o.pid);

        if (compare == 0) {
            return o.pname.compareTo(this.pname);
        } else {
            return compare;
        }
    }

    @Override
    public void write(DataOutput out) throws IOException {
        out.writeUTF(id);
        out.writeUTF(pid);
        out.writeInt(amount);
        out.writeUTF(pname);
    }

    @Override
    public void readFields(DataInput in) throws IOException {
        this.id = in.readUTF();
        this.pid = in.readUTF();
        this.amount = in.readInt();
        this.pname = in.readUTF();
    }
}

RJMapper.java

package com.study.reducejoin;

import com.study.bean.OrderBean;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.NullWritable;
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, OrderBean, NullWritable> {

    private OrderBean orderBean = new OrderBean();

    private String filename;

    @Override
    protected void setup(Context context) throws IOException, InterruptedException {
        FileSplit fs = (FileSplit) context.getInputSplit();
        filename = fs.getPath().getName();
    }

    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        String[] fields = value.toString().split("\t");
        if (filename.equals("order.txt")) {
            orderBean.setId(fields[0]);
            orderBean.setPid(fields[1]);
            orderBean.setAmount(Integer.parseInt(fields[2]));
            orderBean.setPname("");
        } else {
            orderBean.setPid(fields[0]);
            orderBean.setPname(fields[1]);
            orderBean.setId("");
            orderBean.setAmount(0);
        }
        context.write(orderBean, NullWritable.get());
    }
    }

RJComparator.java

package com.study.reducejoin;

import com.study.bean.OrderBean;
import org.apache.hadoop.io.WritableComparable;
import org.apache.hadoop.io.WritableComparator;

public class RJComparator extends WritableComparator {

    protected RJComparator() {
        super(OrderBean.class, true);
    }

    @Override
    public int compare(WritableComparable a, WritableComparable b) {
        OrderBean oa = (OrderBean) a;
        OrderBean ob = (OrderBean) b;
        return oa.getPid().compareTo(ob.getPid());
    }
}

RJReducer.java

package com.study.reducejoin;

import com.study.bean.OrderBean;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.mapreduce.Reducer;

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

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

    @Override
    protected void reduce(OrderBean key, Iterable<NullWritable> values, Context context) throws IOException, InterruptedException {
        //拿到迭代器
        Iterator<NullWritable> iterator = values.iterator();
        //数据指针下移，获取第一个OrderBean
        iterator.next();
        //从第一个OrderBean中取出品牌名称
        String pname = key.getPname();

        //遍历剩下的OrderBean，设置品牌名称并写出
        while (iterator.hasNext()) {
            iterator.next();
            key.setPname(pname);
            context.write(key, NullWritable.get());
        }
    }
}

RJDriver.java

package com.study.reducejoin;

import com.study.bean.OrderBean;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

import java.io.IOException;

public class RJDriver {
    public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
        Job job = Job.getInstance(new Configuration());

        job.setJarByClass(RJDriver.class);

        job.setMapperClass(RJMapper.class);
        job.setReducerClass(RJReducer.class);

        job.setMapOutputKeyClass(OrderBean.class);
        job.setMapOutputValueClass(NullWritable.class);

        job.setOutputKeyClass(OrderBean.class);
        job.setOutputValueClass(NullWritable.class);

        job.setGroupingComparatorClass(RJComparator.class);

        FileInputFormat.setInputPaths(job, new Path("d:\\input"));
        FileOutputFormat.setOutputPath(job, new Path("d:\\output"));

        boolean b = job.waitForCompletion(true);
        System.exit(b ? 0 : 1);
    }
}

运行之前，先在d盘添加input文件并在该文件下添加数据：

在这里插入图片描述
order：

1001	01	1
1002	02	2
1003	03	3
1004	01	4
1005	02	5
1006	03	6

pd：

01	小米
02	华为
03	格力

注意：若d盘存在output文件需要删除在运行

运行程序后，生成文件
在这里插入图片描述
在这里插入图片描述
总结：
在这里插入图片描述

Map Join

1．使用场景

Map Join适用于一张表十分小、一张表很大的场景。

2．优点

思考：在Reduce端处理过多的表，非常容易产生数据倾斜。怎么办？
在Map端缓存多张表，提前处理业务逻辑，这样增加Map端业务，减少Reduce端数据的压力，尽可能的减少数据倾斜。

3．具体办法：采用DistributedCache

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

Map Join案例实操
首先创建mapjoin包创建两个类
在这里插入图片描述

MJMapper.java

package com.study.mapjoin;

import org.apache.commons.lang.StringUtils;
import org.apache.hadoop.fs.FSDataInputStream;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IOUtils;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

import java.io.*;
import java.net.URI;
import java.util.HashMap;
import java.util.Map;

public class MJMapper extends Mapper<LongWritable, Text, Text, NullWritable> {


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

    private Text k = new Text();

    @Override
    protected void setup(Context context) throws IOException, InterruptedException {
        URI[] cacheFiles = context.getCacheFiles();
        String path = cacheFiles[0].getPath().toString();
        FileSystem fileSystem = FileSystem.get(context.getConfiguration());
        FSDataInputStream bufferedReader = fileSystem.open(new Path(path));
        String line;
        while (StringUtils.isNotEmpty(line = bufferedReader.readLine())) {
            String[] fields = line.split("\t");
            pMap.put(fields[0], fields[1]);
        }
        IOUtils.closeStream(bufferedReader);
    }

    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        String[] fields = value.toString().split("\t");
        String pname = pMap.get(fields[1]);
        if (pname == null) {
            pname = "NULL";
        }
        k.set(fields[0] + "\t" + pname + "\t" + fields[2]);
        context.write(k, NullWritable.get());
    }
}

MJDriver.java

package com.study.mapjoin;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

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

    public class MJDriver {


    public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
        Job job = Job.getInstance(new Configuration());

        job.setJarByClass(MJDriver.class);

        job.setMapperClass(MJMapper.class);
        job.setNumReduceTasks(0);

        job.addCacheFile(URI.create("file:///d:/input/pd.txt"));

        FileInputFormat.setInputPaths(job, new Path("d:\\input\\order.txt"));
        FileOutputFormat.setOutputPath(job, new Path("d:\\output"));

        boolean b = job.waitForCompletion(true);
        System.exit(b ? 0 : 1);
    }
}

启动程序，运行
在这里插入图片描述

江湖侠客
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
access，在一个语句中使用多个连接（join）的方法
jieru_liu的博客
05-31 1706
将上面的数据《课程》表，通过自连接，得到如下的交叉表 select * from ((( (SELECT DISTINCT mname FROM 课程) C0 LEFT JOIN (SELECT mname as SQL_name FROM 课程 WHERE course = 'SQL入门' ) as C1 ON C0.mname = C1.sql_name ) LEFT JOIN (SELECT mname as UNIX_name FROM 课程 WHERE course = 'UNIX基.
joinmap4.0
11-15
JoinMap 4.0 是一款在遗传学领域广泛应用的软件，专为构建和分析遗传连锁图谱而设计。这款软件适用于农林牧等多个领域的研究，通过高效的数据处理和统计分析，帮助科研人员揭示基因定位、遗传变异规律以及物种进化等...
MapReduce07 Join多种应用
好好学习天天向上
05-04 210
文章目录1 Join多种应用1.1 Reduce Join1.2 Reduce Join实例实操需求需求分析Map数据处理Reduce端合并(数据倾斜)代码实现JoinBean类JoinMapJoinReduce执行结果总结1.3 Map Join1.4 Map Join案例实操需求分析代码实现MapJoinDriveMapJoinMapper 1 Join多种应用 1.1 Reduce Join Map 端的主要工作：不同表或文件的 key/value 对， 打标签以区别不同来源的记录。然后用连接字段作为
【3.5】Join多种应用
weixin_43958974的博客
02-23 109
1.Reduce Join Reduce Join工作原理 2.Reduce Join案例实操 需求 需求分析 代码实现 (待续) Reduce Join缺点及解决方案 3.Map Join 使用场景 Map Join 适用于一张表十分小、一张表很大的场景。 优点 具体办法：采用DistributedCache 4.Map Join案例实操 需求 MapJ...
Hadoop中Join多种应用
qq_43193797的博客
01-09 2140
总结： Join： 将两个中的字段，通过公共字段进行关联！          MR ：                 ①在Reduce端Join                         1.保证两个文件中的所有字段，都必须达到Reduce!需要将两个文件的所有字段封装为一个Bean                         2.在Map端，为每个文件，打上标记          ...
你知道 Join 有多少种用法吗？
逆流者的博客
03-30 588
先看一张图，像不像数学中的集合，并集，交集，差集啥的。 下面我就用具体的例子来演示上图的7种情况： 新建两张表：t_emp和t_dept（员工表和部门表），这里约定一下，员工表t_emp代表图中A表，部门表t_dept代表图中B表。 创建表并插入数据： DROP TABLE IF EXISTS `t_emp`; DROP TABLE IF EXISTS `t_dept`; CREATE TABLE `t_dept` ( `id` INT(11) NOT NULL AUTO_INCREMENT COMME
数据库应用技术：SQLJOIN多表查询.pptx
03-24
JOIN多表查询分为多种类型，主要包括： 1. **内连接（INNER JOIN）**：只返回两个表中匹配的记录，即两个表的交集。在SQL中，INNER JOIN 或者简单的 JOIN 都表示内连接。例如： ```sql SELECT column_name(s) ...
SQL中的left outer join,inner join,right outer join用法详解
12-17
SQL 提供了多种类型的连接方式，它们之间的区别在于：从相互交叠的不同数据集合中选择用于连接的行时所采用的方法不同。 1. 内连接（Inner Join）：只连接匹配的行。 2. 左外连接（Left Outer Join）：包含左边表的...
hadoop Join代码（map join 和reduce join）
12-10
Hive和Pig都支持多种JOIN类型，如LEFT JOIN、RIGHT JOIN、FULL OUTER JOIN等，并且能够自动优化JOIN策略。 Hive示例： ```sql SELECT a.*, b.* FROM table_a JOIN table_b ON (a.join_field = b.join_field); `...
Join LeetCode.zip
最新发布
02-04
1. **题解资料**：LeetCode上的问题通常涵盖多种编程语言（如Java、Python、C++等），压缩包可能包含这些语言的解题思路、代码实现和解析，帮助用户理解复杂的算法和数据结构。 2. **实战模拟**：可能包含模拟...
SQL的多种JOIN
weixin_30872671的博客
06-07 54
转载于:https://www.cnblogs.com/liuqifeng/p/9150750.html
java多个join_Java多线程神器：join使用及原理
weixin_34684880的博客
02-19 177
join()join()是线程类Thread的方法，官方的说明是：Waits for this thread to die.等待这个线程结束，也就是说当前线程等待这个线程结束后再继续执行，下面来看这个示例就明白了。示例public static void main(String[] args) throws Exception {System.out.println("start");Thread...
join的七种用法
热门推荐
suo_jia_hao的博客
06-15 1万+
join的7种连接方式 sq199语法才有join 语法: ​ select 查询列表 ​ from 表1 别名 [连接类型] ​ join 表2 别名 ​ on 连接条件 ​ [where 筛选条件] ​ [group by 分组] ​ [having 筛选条件] ​ [order by 排序列表] 分类: 内连接(※):inner join 外连接: ​ 左外连接(※):left[outer] ​ 右外连接(※):right[outer] ​ 全外连接:ful
mysql多种join_MySQL的几种Join
weixin_30127493的博客
02-04 97
/* 左表t1*/DROP TABLE IF EXISTS t1;CREATE TABLE t1 (id INT NOT NULL,NAME VARCHAR(20));INSERT INTO t1 VALUES (1,‘t1a‘);INSERT INTO t1 VALUES (2,‘t1b‘);INSERT INTO t1 VALUES (3,‘t1c‘);INSERT INTO t1 VALUE...
MYSQL几种JOIN的初试
djliu2的博客
09-09 272
首先INNER JOIN 假设A表有十条数据 B表有两条数据 A/B两表通过一个userid（以下的链接都是基于这个标准）关联 A内连接B的话出来的就是ID相等的那两条数据。 LEFT JOIN就是讲A表的十条数据全部列出来，再加上B表相关的数据 剩下的不足十条的部分都会用NULL表示. RIGHT JOIN反之。 MYSQL的全链接需要靠UNION ALL这个关键字来完成。 目前对链接的...
如何同时使用多个join——多个连续的left join连接顺序验证
kennyharris
10-18 3456
在实际工作中，很多情况下会用到外连接，尤其是做主页面的数据展示查询时，连续用到多个left join会很常见，这样的多个left join会怎么样执行呢，之前在网上查到的执行顺序是，顺序的从坐到右的连接表，例如有 a,b,c三张表的数据都需要查到，就需要进行连接查询，如 select * from a left join b on a.id = b.id left join a.id = c.id，这时是怎么顺序进行执行的呢？
练习：将多个join串联起来进行查询
readimprove的博客
06-01 899
数据参考：https://www.cnblogs.com/jingzhenhua/p/5947416.html 我将数据改成了适用于MySQL的格式，具体脚本如下： create table student( sno varchar(5) primary key, sname varchar(9) not null, ssex varchar(3) not null, sbirt...
MySQL实现7种 SQL JOINS
一份耕耘，一分收获
04-28 3430
MySQL实现7种SQL JOINS，包含UNION 和 UNION ALL关键字使用
多个join的执行过程
学习小天地
08-02 2175
嵌套循环连接，就是先根据Join的类型和on条件进行逐层连接，每次连接完后用where对结果进行过滤。 在这个例子里，第一步只有A一个表，所以没有join的操作，直接对A用where a.id in (1,2，3，4，5，6)进行过滤，符合条件的记录作为主表，得到临时表t_A；第二步，t_A和B按照 A left join B b on a.bid = b.id 的规则来连接，对结果b.class...
分布式Join技术探析：从单机到优化策略
它支持多种Join类型，如InnerJoin、LeftJoin、RightJoin和OuterJoin，但效率较低，因为其时间复杂度较高，特别是在数据量大时。 2. MergeJoin MergeJoin依赖于两个输入表已经按照Join键排序。它的优点在于具有较低...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值