MapReduce--MapJoin、ReduceJoin、TopN

最新推荐文章于 2022-02-15 23:06:11 发布
最新推荐文章于 2022-02-15 23:06:11 发布
阅读量192 收藏
点赞数
分类专栏： Hadoop 文章标签： mapreduce hadoop java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41301707/article/details/110934389
版权

                  MapReduce--MapJoin、ReduceJoin、TopN

 

1. MapReduce Join

  • Join分为两种：一种是Map Join,一种是Reduce Join
  • MapJoin 指的是在Map端进行Join，没有Reduce,所以没有Shuffle
  • ReduceJoin 指的是在Reduce端进行Join,存在Reduce，存在Shuffle
  • 在大数据领域经常听到数据倾斜这个词，数据倾斜的原因是由于某个Key的数量过多，导致Reduce里面的数据不均匀导致的，会出现某个Reduce task执行速度过慢，导致整个job执行速度比较慢
  • 数据倾斜是发生在Shuffle阶段，为了避免数据倾斜，即避免Shuffle,可以使用MapJoin

 

2 MapJoin

2.1 使用场景

  • 一个大表Join小表

2.2 具体做法

  • 在启动mapreduce的方法里面缓存文件路径
  • 在Mapper的setup阶段，将文件读取到缓存集合中
  • 在map阶段进行匹配数据

2.3 需求

把dept和emp数据进行MapJoin

2.4 数据

2.4.1 dept.txt

deptno,dname,message
10	ACCOUNTING	NEW YORK
20	RESEARCH	DALLAS
30	SALES	CHICAGO
40	OPERATIONS	BOSTON

2.4.2 emp.txt

empno,ename,deptno
7369	SMITH	20
7499	ALLEN	30
7521	WARD	30
7566	JONES	20
7654	MARTIN	30
7698	BLAKE	30
7782	CLARK	10
7788	SCOTT	20
7839	KING	10
7844	TURNER	30
7876	ADAMS	20
7900	JAMES	30
7902	FORD	20
7934	MILLER	10

2.5 Code

2.5.1 MapJoinDriver Code

package com.xk.bigata.hadoop.mapreduce.join;

import com.xk.bigata.hadoop.mapreduce.domain.AccessDomain;
import com.xk.bigata.hadoop.mapreduce.domain.DeptWritable;
import com.xk.bigata.hadoop.mapreduce.domain.EmpInfoWritable;
import com.xk.bigata.hadoop.utils.FileUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URI;
import java.util.HashMap;
import java.util.Map;

public class MapJoinDriver {

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

        String input = "mapreduce-basic/data/join/emp.txt";
        String output = "mapreduce-basic/out";

        // 1 创建 MapReduce job
        Configuration conf = new Configuration();
        Job job = Job.getInstance(conf);

        // 删除输出路径
        FileUtils.deleteFile(job.getConfiguration(), output);

        // 2 设置运行主类
        job.setJarByClass(MapJoinDriver.class);

        // 3 设置Map和Reduce运行的类
        job.setMapperClass(MyMapper.class);

        // 4 设置Map 输出的 KEY 和 VALUE 数据类型
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(AccessDomain.class);

        // 6 设置输入和输出路径
        FileInputFormat.setInputPaths(job, new Path(input));
        FileOutputFormat.setOutputPath(job, new Path(output));

        // 设置reduce task 数量
        job.setNumReduceTasks(0);

        // 缓存dept路径
        job.addCacheFile(new URI("mapreduce-basic/data/join/dept.txt"));

        // 7 提交job
        boolean result = job.waitForCompletion(true);
        System.exit(result ? 0 : 1);

    }

    public static class MyMapper extends Mapper<LongWritable, Text, EmpInfoWritable, NullWritable> {

        Map<Integer, DeptWritable> cache = new HashMap<>();

        // 把文件放在缓存的map里面
        @Override
        protected void setup(Context context) throws IOException, InterruptedException {
            String deptPath = context.getCacheFiles()[0].getPath();
            BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(deptPath)));
            String message = null;
            while (!StringUtils.isEmpty(message = reader.readLine())) {
                String[] split = message.split("\t");
                cache.put(Integer.parseInt(split[0]), new DeptWritable(Integer.parseInt(split[0]), split[1], split[2]));
            }
            reader.close();
        }

        @Override
        protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
            String[] spilts = value.toString().split("\t");
            int deptNo = Integer.parseInt(spilts[2]);
            DeptWritable deptWritable = cache.get(deptNo);
            // int empNo, String eName, int deptNo, String dName, String dMessage
            EmpInfoWritable empInfoWritable = new EmpInfoWritable(Integer.parseInt(spilts[0]), spilts[1], deptNo, deptWritable.getdName(), deptWritable.getdMessage());
            context.write(empInfoWritable, NullWritable.get());
        }
    }
}

2.5.2 DeptWritable Code

package com.xk.bigata.hadoop.mapreduce.domain;

import org.apache.hadoop.io.Writable;

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

public class DeptWritable implements Writable {

    private Integer deptNo;

    private String dName;

    private String dMessage;

    public DeptWritable() {
    }

    @Override
    public String toString() {
        return deptNo + "\t" + dName + "\t" + dMessage;
    }

    public DeptWritable(Integer deptNo, String dName, String dMessage) {
        this.deptNo = deptNo;
        this.dName = dName;
        this.dMessage = dMessage;
    }

    public int getDeptNo() {
        return deptNo;
    }

    public void setDeptNo(int deptNo) {
        this.deptNo = deptNo;
    }

    public String getdName() {
        return dName;
    }

    public void setdName(String dName) {
        this.dName = dName;
    }

    public String getdMessage() {
        return dMessage;
    }

    public void setdMessage(String dMessage) {
        this.dMessage = dMessage;
    }

    @Override
    public void write(DataOutput out) throws IOException {
        out.writeInt(deptNo);
        out.writeUTF(dName);
        out.writeUTF(dMessage);
    }

    @Override
    public void readFields(DataInput in) throws IOException {
        this.deptNo = in.readInt();
        this.dName = in.readUTF();
        this.dMessage = in.readUTF();
    }
}

2.5.3 EmpWritable Code

package com.xk.bigata.hadoop.mapreduce.domain;

import org.apache.hadoop.io.Writable;

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

public class EmpWritable implements Writable {

    private int empNo;

    private String eName;

    private int deptNo;

    @Override
    public String toString() {
        return empNo + "\t" + eName + "\t" + deptNo;
    }

    public EmpWritable() {
    }

    public EmpWritable(int empNo, String eName, int deptNo) {
        this.empNo = empNo;
        this.eName = eName;
        this.deptNo = deptNo;
    }

    public int getEmpNo() {
        return empNo;
    }

    public void setEmpNo(int empNo) {
        this.empNo = empNo;
    }

    public String geteName() {
        return eName;
    }

    public void seteName(String eName) {
        this.eName = eName;
    }

    public int getDeptNo() {
        return deptNo;
    }

    public void setDeptNo(int deptNo) {
        this.deptNo = deptNo;
    }

    @Override
    public void write(DataOutput out) throws IOException {
        out.writeInt(empNo);
        out.writeUTF(eName);
        out.writeInt(deptNo);
    }

    @Override
    public void readFields(DataInput in) throws IOException {
        this.empNo = in.readInt();
        this.eName = in.readUTF();
        this.deptNo = in.readInt();
    }
}

2.5.4 EmpInfoWritable Code

package com.xk.bigata.hadoop.mapreduce.domain;

import org.apache.hadoop.io.Writable;

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

public class EmpInfoWritable implements Writable {

    private int empNo;

    private String eName;

    private int deptNo;

    private String dName;

    private String dMessage;

    @Override
    public String toString() {
        return empNo + "\t" + eName + "\t" +
                deptNo + "\t" + dName + "\t" +
                dMessage;
    }

    public EmpInfoWritable(int empNo, String eName, int deptNo, String dName, String dMessage) {
        this.empNo = empNo;
        this.eName = eName;
        this.deptNo = deptNo;
        this.dName = dName;
        this.dMessage = dMessage;
    }

    public EmpInfoWritable() {
    }

    public int getEmpNo() {
        return empNo;
    }

    public void setEmpNo(int empNo) {
        this.empNo = empNo;
    }

    public String geteName() {
        return eName;
    }

    public void seteName(String eName) {
        this.eName = eName;
    }

    public int getDeptNo() {
        return deptNo;
    }

    public void setDeptNo(int deptNo) {
        this.deptNo = deptNo;
    }

    public String getdName() {
        return dName;
    }

    public void setdName(String dName) {
        this.dName = dName;
    }

    public String getdMessage() {
        return dMessage;
    }

    public void setdMessage(String dMessage) {
        this.dMessage = dMessage;
    }

    @Override
    public void write(DataOutput out) throws IOException {
        out.writeInt(empNo);
        out.writeUTF(eName);
        out.writeInt(deptNo);
        out.writeUTF(dName);
        out.writeUTF(dMessage);
    }

    @Override
    public void readFields(DataInput in) throws IOException {
        this.empNo = in.readInt();
        this.eName = in.readUTF();
        this.deptNo = in.readInt();
        this.dName = in.readUTF();
        this.dMessage = in.readUTF();
    }
}

2.6 结果

7369	SMITH	20	RESEARCH	DALLAS
7499	ALLEN	30	SALES	CHICAGO
7521	WARD	30	SALES	CHICAGO
7566	JONES	20	RESEARCH	DALLAS
7654	MARTIN	30	SALES	CHICAGO
7698	BLAKE	30	SALES	CHICAGO
7782	CLARK	10	ACCOUNTING	NEW YORK
7788	SCOTT	20	RESEARCH	DALLAS
7839	KING	10	ACCOUNTING	NEW YORK
7844	TURNER	30	SALES	CHICAGO
7876	ADAMS	20	RESEARCH	DALLAS
7900	JAMES	30	SALES	CHICAGO
7902	FORD	20	RESEARCH	DALLAS
7934	MILLER	10	ACCOUNTING	NEW YORK

MapJoinDriver Code

 

3 Reduce Join

3.1 使用场景

  • 大表Join 大表

3.2 具体做法

  • 先把两个文件的数据全部加载到Map里面
  • 通过增加一个标识符来判断进来的是emp数据还是dept数据
  • 在Reduce端进行Join操作

3.3 需求

把dept和emp数据进行ReduceJoin

3.4 数据

3.4.1 dept.txt

deptno,dname,message
10	ACCOUNTING	NEW YORK
20	RESEARCH	DALLAS
30	SALES	CHICAGO
40	OPERATIONS	BOSTON

3.4.2 emp.txt

empno,ename,deptno
7369	SMITH	20
7499	ALLEN	30
7521	WARD	30
7566	JONES	20
7654	MARTIN	30
7698	BLAKE	30
7782	CLARK	10
7788	SCOTT	20
7839	KING	10
7844	TURNER	30
7876	ADAMS	20
7900	JAMES	30
7902	FORD	20
7934	MILLER	10

3.5 Code

 3.5.1 ReduceJoinDriver Code

package com.xk.bigata.hadoop.mapreduce.join;

import com.xk.bigata.hadoop.mapreduce.domain.EmpInfoReduceJoinWritable;
import com.xk.bigata.hadoop.utils.FileUtils;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.NullWritable;
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;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class ReduceJoinDriver {

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

        String input = "mapreduce-basic/data/join";
        String output = "mapreduce-basic/out";

        // 1 创建 MapReduce job
        Configuration conf = new Configuration();
        Job job = Job.getInstance(conf);

        // 删除输出路径
        FileUtils.deleteFile(job.getConfiguration(), output);

        // 2 设置运行主类
        job.setJarByClass(ReduceJoinDriver.class);

        // 3 设置Map和Reduce运行的类
        job.setMapperClass(MyMapper.class);
        job.setReducerClass(MyReduce.class);

        // 4 设置Map 输出的 KEY 和 VALUE 数据类型
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(EmpInfoReduceJoinWritable.class);

        // 5 设置Reduce 输出 KEY 和 VALUE 数据类型
        job.setOutputKeyClass(EmpInfoReduceJoinWritable.class);
        job.setOutputValueClass(NullWritable.class);

        // 6 设置输入和输出路径
        FileInputFormat.setInputPaths(job, new Path(input));
        FileOutputFormat.setOutputPath(job, new Path(output));

        // 7 提交job
        boolean result = job.waitForCompletion(true);
        System.exit(result ? 0 : 1);

    }

    public static class MyMapper extends Mapper<LongWritable, Text, Text, EmpInfoReduceJoinWritable> {

        private String fileName;

        @Override
        protected void setup(Context context) throws IOException, InterruptedException {
            // 确定读取的是哪一个文件
            FileSplit fileSplit = (FileSplit) context.getInputSplit();
            fileName = fileSplit.getPath().getName();
        }

        @Override
        protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
            if (fileName.contains("dept")) {
                // 进入的数据是dept
                String[] spits = value.toString().split("\t");
                EmpInfoReduceJoinWritable empInfoReduceJoinWritable = new EmpInfoReduceJoinWritable();
                empInfoReduceJoinWritable.setDeptNo(Integer.parseInt(spits[0]));
                empInfoReduceJoinWritable.setdName(spits[1]);
                empInfoReduceJoinWritable.setdMessage(spits[2]);
                empInfoReduceJoinWritable.setEmpNo(0);
                empInfoReduceJoinWritable.setFlg("0");
                empInfoReduceJoinWritable.seteName("");
                context.write(new Text(spits[0]), empInfoReduceJoinWritable);
            } else if (fileName.contains("emp")) {
                // 进来的数据是emp
                String[] splits = value.toString().split("\t");
                EmpInfoReduceJoinWritable empInfoReduceJoinWritable = new EmpInfoReduceJoinWritable();
                empInfoReduceJoinWritable.setEmpNo(Integer.parseInt(splits[0]));
                empInfoReduceJoinWritable.seteName(splits[1]);
                empInfoReduceJoinWritable.setDeptNo(Integer.parseInt(splits[2]));
                empInfoReduceJoinWritable.setFlg("1");
                empInfoReduceJoinWritable.setdMessage("");
                empInfoReduceJoinWritable.setdName("");
                context.write(new Text(splits[2]), empInfoReduceJoinWritable);
            }
        }
    }

    public static class MyReduce extends Reducer<Text, EmpInfoReduceJoinWritable, EmpInfoReduceJoinWritable, NullWritable> {
        // 相同的deptno(key)所对应的emp 和 dept的数据都落在了values
        @Override
        protected void reduce(Text key, Iterable<EmpInfoReduceJoinWritable> values, Context context) throws IOException, InterruptedException {
            List<EmpInfoReduceJoinWritable> emps = new ArrayList<>();
            String dName = null;
            String dMessage = null;
            for (EmpInfoReduceJoinWritable emp : values) {
                if (emp.getFlg().equals("1")) {
                    // 数据来自emp
                    EmpInfoReduceJoinWritable empInfoReduceJoinWritable = new EmpInfoReduceJoinWritable();
                    empInfoReduceJoinWritable.setEmpNo(emp.getEmpNo());
                    empInfoReduceJoinWritable.seteName(emp.geteName());
                    empInfoReduceJoinWritable.setDeptNo(emp.getDeptNo());
                    emps.add(empInfoReduceJoinWritable);
                } else {
                    // 数据来自dept
                    dName = emp.getdName();
                    dMessage = emp.getdMessage();
                }
            }

            for (EmpInfoReduceJoinWritable bean : emps) {
                bean.setdName(dName);
                bean.setdMessage(dMessage);
                context.write(bean, NullWritable.get());
            }

        }
    }

}

3.5.2 EmpInfoReduceJoinWritable Code

package com.xk.bigata.hadoop.mapreduce.domain;

import org.apache.hadoop.io.Writable;

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

public class EmpInfoReduceJoinWritable implements Writable {

    private int empNo;

    private String eName;

    private int deptNo;

    private String dName;

    private String dMessage;

    private String flg;

    @Override
    public String toString() {
        return empNo + "\t" + eName + "\t" +
                deptNo + "\t" + dName + "\t" +
                dMessage;
    }

    public EmpInfoReduceJoinWritable(int empNo, String eName, int deptNo, String dName, String dMessage, String flg) {
        this.empNo = empNo;
        this.eName = eName;
        this.deptNo = deptNo;
        this.dName = dName;
        this.dMessage = dMessage;
        this.flg = flg;
    }

    public EmpInfoReduceJoinWritable() {
    }

    public int getEmpNo() {
        return empNo;
    }

    public void setEmpNo(int empNo) {
        this.empNo = empNo;
    }

    public String geteName() {
        return eName;
    }

    public void seteName(String eName) {
        this.eName = eName;
    }

    public int getDeptNo() {
        return deptNo;
    }

    public void setDeptNo(int deptNo) {
        this.deptNo = deptNo;
    }

    public String getdName() {
        return dName;
    }

    public void setdName(String dName) {
        this.dName = dName;
    }

    public String getdMessage() {
        return dMessage;
    }

    public void setdMessage(String dMessage) {
        this.dMessage = dMessage;
    }

    public String getFlg() {
        return flg;
    }

    public void setFlg(String flg) {
        this.flg = flg;
    }

    @Override
    public void write(DataOutput out) throws IOException {
        out.writeInt(empNo);
        out.writeUTF(eName);
        out.writeInt(deptNo);
        out.writeUTF(dName);
        out.writeUTF(dMessage);
        out.writeUTF(flg);
    }

    @Override
    public void readFields(DataInput in) throws IOException {
        this.empNo = in.readInt();
        this.eName = in.readUTF();
        this.deptNo = in.readInt();
        this.dName = in.readUTF();
        this.dMessage = in.readUTF();
        this.flg = in.readUTF();
    }
}

3.6 结果

7934	MILLER	10	ACCOUNTING	NEW YORK
7839	KING	10	ACCOUNTING	NEW YORK
7782	CLARK	10	ACCOUNTING	NEW YORK
7876	ADAMS	20	RESEARCH	DALLAS
7788	SCOTT	20	RESEARCH	DALLAS
7369	SMITH	20	RESEARCH	DALLAS
7566	JONES	20	RESEARCH	DALLAS
7902	FORD	20	RESEARCH	DALLAS
7844	TURNER	30	SALES	CHICAGO
7499	ALLEN	30	SALES	CHICAGO
7698	BLAKE	30	SALES	CHICAGO
7654	MARTIN	30	SALES	CHICAGO
7521	WARD	30	SALES	CHICAGO
7900	JAMES	30	SALES	CHICAGO

ReduceJoinDriver Code

 

4 TopN

  • 分组TopN就是先分组，然后取每个组内某个字段聚合结果比较多的前N

4.1 需求

emp数据每个部门的薪资Top前两名
第一个字段是工号
第二个字段是姓名
倒数第二个字段是薪资
倒数第一字段是部门编号

4.2 数据

7369	SMITH	CLERK	7902	1980-12-17	800.00		20
7499	ALLEN	SALESMAN	7698	1981-2-20	1600.00	300.00	30
7521	WARD	SALESMAN	7698	1981-2-22	1250.00	500.00	30
7566	JONES	MANAGER	7839	1981-4-2	2975.00		20
7654	MARTIN	SALESMAN	7698	1981-9-28	1250.00	1400.00	30
7698	BLAKE	MANAGER	7839	1981-5-1	2850.00		30
7782	CLARK	MANAGER	7839	1981-6-9	2450.00		10
7788	SCOTT	ANALYST	7566	1987-4-19	3000.00		20
7839	KING	PRESIDENT		1981-11-17	5000.00		10
7844	TURNER	SALESMAN	7698	1981-9-8	1500.00	0.00	30
7876	ADAMS	CLERK	7788	1987-5-23	1100.00		20
7900	JAMES	CLERK	7698	1981-12-3	950.00		30
7902	FORD	ANALYST	7566	1981-12-3	3000.00		20
7934	MILLER	CLERK	7782	1982-1-23	1300.00		10

4.3 Code

4.3.1 TopNEmpWritable Code

package com.xk.bigata.hadoop.mapreduce.top;

import org.apache.hadoop.io.Writable;

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

public class TopNEmpWritable implements Writable {

    private int empNo;

    private String eName;

    private int deptNo;

    private double wages;

    @Override
    public String toString() {
        return empNo + "\t" + eName + "\t" + deptNo + "\t" + wages;
    }

    public TopNEmpWritable() {
    }

    public TopNEmpWritable(int empNo, String eName, int deptNo, double wages) {
        this.empNo = empNo;
        this.eName = eName;
        this.deptNo = deptNo;
        this.wages = wages;
    }

    public int getEmpNo() {
        return empNo;
    }

    public void setEmpNo(int empNo) {
        this.empNo = empNo;
    }

    public String geteName() {
        return eName;
    }

    public void seteName(String eName) {
        this.eName = eName;
    }

    public int getDeptNo() {
        return deptNo;
    }

    public void setDeptNo(int deptNo) {
        this.deptNo = deptNo;
    }

    public double getWages() {
        return wages;
    }

    public void setWages(double wages) {
        this.wages = wages;
    }

    @Override
    public void write(DataOutput out) throws IOException {
        out.writeInt(empNo);
        out.writeUTF(eName);
        out.writeInt(deptNo);
        out.writeDouble(wages);
    }

    @Override
    public void readFields(DataInput in) throws IOException {
        this.empNo = in.readInt();
        this.eName = in.readUTF();
        this.deptNo = in.readInt();
        this.wages = in.readDouble();
    }
}

4.3.2 GroupTopDriver Code

package com.xk.bigata.hadoop.mapreduce.top;

import com.xk.bigata.hadoop.utils.FileUtils;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.NullWritable;
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.output.FileOutputFormat;

import java.io.IOException;

public class GroupTopDriver {

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

        String input = "mapreduce-basic/data/emp.data";
        String output = "mapreduce-basic/out";

        // 1 创建 MapReduce job
        Configuration conf = new Configuration();
        Job job = Job.getInstance(conf);

        // 删除输出路径
        FileUtils.deleteFile(job.getConfiguration(), output);

        // 2 设置运行主类
        job.setJarByClass(GroupTopDriver.class);

        // 3 设置Map和Reduce运行的类
        job.setMapperClass(MyMapper.class);
        job.setReducerClass(MyReducer.class);

        // 4 设置Map 输出的 KEY 和 VALUE 数据类型
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(TopNEmpWritable.class);

        // 5 设置Reduce 输出 KEY 和 VALUE 数据类型
        job.setOutputKeyClass(TopNEmpWritable.class);
        job.setOutputValueClass(NullWritable.class);

        // 6 设置输入和输出路径
        FileInputFormat.setInputPaths(job, new Path(input));
        FileOutputFormat.setOutputPath(job, new Path(output));

        // 7 提交job
        boolean result = job.waitForCompletion(true);
        System.exit(result ? 0 : 1);

    }

    public static class MyMapper extends Mapper<LongWritable, Text, Text, TopNEmpWritable> {

        @Override
        protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
            String[] spilts = value.toString().split("\t");
            TopNEmpWritable topNEmpWritable = new TopNEmpWritable(Integer.parseInt(spilts[0]),
                    spilts[1],
                    Integer.parseInt(spilts[7]),
                    Double.parseDouble(spilts[5]));
            context.write(new Text(spilts[7]), topNEmpWritable);
        }
    }

    public static class MyReducer extends Reducer<Text, TopNEmpWritable, TopNEmpWritable, NullWritable> {
        int topN = 2;

        @Override
        protected void reduce(Text key, Iterable<TopNEmpWritable> values, Context context) throws IOException, InterruptedException {
            int index = 1;
            for (TopNEmpWritable value : values) {
                index++;
                context.write(value, NullWritable.get());
                if (index > topN) {
                    break;
                }
            }
        }
    }
}

4.4 结果

7934	MILLER	10	1300.0
7839	KING	10	5000.0
7876	ADAMS	20	1100.0
7788	SCOTT	20	3000.0
7844	TURNER	30	1500.0
7499	ALLEN	30	1600.0

GroupTopDriver Code

 

 

XK&RM
关注
专栏目录
hive的数据倾斜解决（Map端、reduce 端 、join中）
someInNeed的博客
06-17 5379
hive的数据倾斜解决（Map端、reduce 端 、join中） lianchaozhao 2020-11-02 15:24:08 667 收藏 4 分类专栏： 工作实践 hive 大数据 文章标签： hive 大数据 版权 hive 的数据倾斜一般我们可以分为 Map倾斜、reduce 倾斜和join 倾斜这几种。 一、Map 倾斜 Map 端是 MR 任务的起始阶段， Map 端的主要功能是从磁盘中将数据读人内存， Map 端的两个主要过程如图所示。 此处复习仪表map 过程 1、客户..
4 Hadoop-Mapreduce
PhoenixLuo·的博客
05-03 759
目录 4.4 MapReduce 4.4.1 MapReduce 介绍 MapReduce 设计构思 4.4.2 MapReduce 编程规范 4.4.3 WordCount(经典案例） Step 1. 数据格式准备 Step 2. Mapper Step 3. Reducer Step 4. 定义主类, 描述 Job 并提交 Job 4.4.4 MapReduce 运行模式 集群运行模式 本地运行模式 （一般做测试用） 4.4.5 MapReduce 分区 Step 1. 定义
大数据知识专栏 - MapReduce 的 Map端Join
能力工场小马哥
01-22 231
大数据专栏系列文章: 通过该文章, 教会如何在 MapReduce 中使用 Map 端 Join.
MapReduce Join
weixin_47243236的博客
11-29 1266
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之Map Join
weixin_34075551的博客
12-15 200
一介绍 之所以存在Reduce Join，是因为在map阶段不能获取所有需要的join字段，即：同一个key对应的字段可能位于不同map中。Reduce side join是非常低效的，因为shuffle阶段要进行大量的数据传输。 Map Join是针对以下场景进行的优化：两个待连接表中，有一个表非常大，而另一个表非常小，以至于小表可以直接存放到内存中。这样，我们可以将小表复制多份，让每个m...
MapReduce当中map端做join
mark_to_win的专栏
06-02 274
map端做join马克-to-win @ 马克java社区：map端做join和reduce端做join有何区别？我们前面讲的是Reduce端join，因为Reduce端join需要把所有的数据都经过Shuffle，非常消耗资源，效率要远远低于Map端join。Map端join是指只有map工作，reduce不工作，这样可以有效的避免数据倾斜。马克-to-win @ 马克java社区：什么叫数据...
mapreduce之mapjoin
会飞的鱼
01-13 1421
mapjoin指的是在mapreduce的map阶段先加载一个文件缓存到内存当中，这个文件可能是从磁盘读取的或网络请求的都可以。 map(key,value,context)方法中读取的数据key和value，这两个数据和先前缓存到内存中的数据一起做处理后再context.write()到reduce阶段。 mapjoin相当于在map阶段写数据到reduce阶段前对数据做了处理。 比如有两个tx...
MapReduce----3.MapReduce 典型编程场景
XiaodunLP的博客
02-02 243
1、MapReduce 多 Job 串联 1.1、需求 一个稍复杂点的处理逻辑往往需要多个 MapReduce 程序串联处理，多 job 的串联可以借助 MapReduce 框架的 JobControl 实现 1.2、实例 以下有两个 MapReduce 任务，分别是 Flow 的 SumMR 和 SortMR，其中有依赖关系：SumMR 的输出是 SortMR 的输入，所以 SortMR...
拓思爱诺大数据第五天-mapreduce编程
06-24
- **TopN**：找出数据中出现频率最高的N项。 - **Join操作**：模拟数据库中的连接操作，用于处理多表关联的问题。 **2.3 自定义开发** 除了基本的编程模式之外，开发者还可以通过自定义Mapper、Reducer以及...
Hadoop学习笔记[8]-MapReduce样例程序
unlock的博客
02-15 400
Hadoop学习笔记[8]-MapReduce样例程序   写几个MR的小程序吧 1、WordCount   传说中分布式计算领域的Hello Word，就是单词计数，北京和题干就不介绍了 2、分组取Top N 要求如下 有如下的数据集： 2019-06-01 00:00:00#32 2019-05-21 00:00:00#33 2019-06-01 12:00:00#33 2019-06-02 00:00:00#31 2018-03-11 00:00:00#18 2018-04-23 00:00:00#2
MapReduce 之 ---MapJoin
YZY_001的博客
09-02 370
package com.ghgj.cn.mapjoin; import java.io.BufferedReader; import java.io.FileReader; import java.io.IOException; import java.net.URI; import java.net.URISyntaxException; import java.util.HashMap; i...
MapReduce Join应用 Map Join
mengxianglong123的博客
08-08 198
一、概述 1. 使用场景 Map Join适用于一张表十分小、一张表很大的场景。 2. 优点 思考：在Reduce端处理过多的表，非常容易产生数据倾斜。怎么办？ 在Map端缓存多张表，提前处理业务逻辑，这样增加Map端业务，减少Reduce端数据的压力，尽可能的减少数据倾斜。 3. 具体办法：采用DistributedCache （1）在Mapper的setup阶段，将文件读取到缓存集合中。 （2）在Driver驱动类中加载缓存。 //缓存普通文件到Task运行节点。 job.addCacheFile(ne
mapreduce连接_mapJoin
Charles_D
04-08 301
MapJoin 1.作用：reduceJoin在进行数据连接时效率低，用mapJoin来提升数据连接的效率。在map端进行不同数据源的数据连接。 2.DistributeCache： 若进行大数据与小数据的连接，可以将小数据文件复制到所有mapper上，进行map端的连接。在driver中共享cacheFile： job.addCacheFile(new URI("cacheFile")); ...
mapreduce之map端的join
hello world
09-05 530
map-side join: 核心思想：将小表进行分布式缓存，在map-task阶段读取缓存文件数据存储到内存数据结构中，以供reduce阶段连接查找。 适用场景：有一个或者多个小表(文件) 优点：将小表缓存，可以高效查询；由于在map阶段进行连接，所以将会大大减小map到reduce端的数据传输，从而减少不必要的shuffle耗时，提高整个mr的执行效率 缺点：如果业务全是大表不适合 示例 三张...
MapReduce 之Map 端 join
垫脚石的博客
10-11 3031
MapReduce 之Map 端 join 一 前言引入 数据倾斜{数据倾斜在MapReduce编程模型中十分常见,用最通俗易懂的话来说,数据倾斜无非就是大量的相同key被partition分配到一个分区里,造成了'一个人累死,其他人闲死'的情况,这种情况是我们不能接受的,这也违背了并行计算的初衷,首先一个节点要承受着巨大的压力,而其他节点计算完毕后要一直等待这个忙碌的节点,也拖累了整体的计算...
MapReduce的mapJoin算法
v3424的博客
11-13 144
下面是一个完整的mapJoin源码，可以仔细品品哦！！ 所需的数据： orders.txt 1001,20150710,p0001,2 1002,20150710,p0002,3 1002,20150710,p0003,3 product.txt p0001,小米5,1000,2000 p0002,锤子T1,1000,3000 mapJoin只需要两个类，一个是map，一个驱动类。 map类 import org.apache.hadoop.filecache.DistributedCache;
MapReduce之Map join操作
Reader
01-16 393
MapReduce之Map join操作 文章目录MapReduce之Map join操作案例结合利用MapReduce中的setup方法与DistributedCacheDistributedCache(分布式缓存)Main(主类)Map(含改进前与改进后对比)Partitioner(自定义分组)Bean(实现组内排序)Reduce(取Top3)结果：![在这里插入图片描述](https://img-blog.csdnimg.cn/20210116183255438.png?x-oss-process=i
MapReduce表连接操作之Map端join
浅汐
10-08 377
一：背景 MapReduce提供了表连接操作其中包括Map端join、Reduce端join还有半连接，现在我们要讨论的是Map端join，Map端join是指数据到达map处理函数之前进行合并的，效率要远远高于Reduce端join，因为Reduce端join是把所有的数据都经过Shuffle，非常消耗资源。 二：技术实现 基本思路： (1)：需要join的两个文件，一个存储在H
MapReduce Join操作解析：MapSide Join与ReduceSide Join
"本文主要介绍了MapReduce框架中的两种JOIN操作：Map Side Join和Reduce Side Join，以及它们在处理分布式数据集关联时的应用和优缺点。" MapReduce是一种用于处理和生成大数据集的分布式计算模型，它由两个主要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值