大数据之hadoop中MapReduce的join应用

        join应用主要是将两个表的数据进行合并操作。分别在map端和reduce端。

1、ReduceJoin

        Map 端的主要工作：为来自不同表或文件的 key/value 对，打标签以区别不同来源的记 录。然后用连接字段作为 key，其余部分和新加的标志作为 value，最后进行输出。

        Reduce 端的主要工作：在 Reduce 端以连接字段作为 key 的分组已经完成，我们只需要 在每一个分组当中将那些来源于不同文件的记录（在 Map 阶段已经打标志）分开，最后进 行合并就 ok 了。

案例：将order.txt和pd.txt的数据合并在一起。

        数据准备：

           

        需求分析：通过将关联条件作为 Map 输出的 key，将两表满足 Join 条件的数据并携带数据所来源 的文件信息，发往同一个 ReduceTask，在 Reduce 中进行数据的串联。

        序列化阶段：由于数据表字段不同，因而将两个表的字段封装在一起

package cn.itjdb.mapreduce.reducejoin;

import org.apache.hadoop.io.Writable;

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

/**
 * 实现序列化，对数据进行封装
 */

public class TableBean implements Writable {
    private String id;
    private String pid;
    private Integer amount;
    private String pname;
    private String flag;  //用来定义表名

    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 Integer getAmount() {
        return amount;
    }

    public void setAmount(Integer amount) {
        this.amount = amount;
    }

    public String getPname() {
        return pname;
    }

    public void setPname(String pname) {
        this.pname = pname;
    }

    public String getFlag() {
        return flag;
    }

    public void setFlag(String flag) {
        this.flag = flag;
    }

    //实现空参构造
    public TableBean() {
    }

    //实现序列化方法
    @Override
    public void write(DataOutput out) throws IOException {
        out.writeUTF(id);
        out.writeUTF(pid);
        out.writeInt(amount);
        out.writeUTF(pname);
        out.writeUTF(flag);
    }

    //实现反序列化
    @Override
    public void readFields(DataInput in) throws IOException {
        this.id=in.readUTF();
        this.pid=in.readUTF();
        this.amount=in.readInt();
        this.pname=in.readUTF();
        this.flag=in.readUTF();
    }

    //toString方法

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

编写mapper类

package cn.itjdb.mapreduce.reducejoin;

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 TableMapper extends Mapper<LongWritable,Text, Text,TableBean> {
    private String filename;
    private Text outK=new Text();
    private TableBean outV=new TableBean();
    //在map方法之前处理可以避免每次读取数据的时候都获取一遍
    @Override
    protected void setup(Context context) throws IOException, InterruptedException {
        //初始化方法，首先获取要进行处理的文件名称
        FileSplit split = (FileSplit) context.getInputSplit();
        filename = split.getPath().getName();
    }

    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        //获取一行
        String line = value.toString();
        //划分数据
        String[] split = line.split("\t");
        if (filename.contains("order")){
            //对数据进行封装
            outK.set(split[1]);
            outV.setId(split[0]);
            outV.setPid(split[1]);
            outV.setAmount(Integer.parseInt(split[2]));
            outV.setPname("");
            outV.setFlag("order");
        }else{
            //当表为商品表时
            outK.set(split[0]);
            outV.setId("");
            outV.setPid(split[0]);
            outV.setAmount(0);
            outV.setPname(split[1]);
            outV.setFlag("pd");
        }
        context.write(outK,outV);
    }
}

编写reduce类

package cn.itjdb.mapreduce.reducejoin;

import org.apache.commons.beanutils.BeanUtils;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;


import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;

public class TableReduce extends Reducer<Text,TableBean,TableBean, NullWritable> {
    @Override
    protected void reduce(Text key, Iterable<TableBean> values, Context context) throws IOException, InterruptedException {
        //准备初始化集合
        ArrayList<TableBean> orderBeans = new ArrayList<>();
        TableBean pdBean = new TableBean(); //创建的是临时存储对象

        //循环遍历数据对数据进行分类
        for (TableBean value : values) {
            if ("order".equals(value.getFlag())){//订单表
                //创建一个临时 TableBean 对象接收 value
                TableBean tmpOrderBean = new TableBean();

                //将数据赋值到临时的TableBean对象中
                try {
                    BeanUtils.copyProperties(tmpOrderBean,value);
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    e.printStackTrace();
                }
                //将临时的TableBean对象中的数据添加到集合orderBeans中
                orderBeans.add(tmpOrderBean);
            }else {//商品表
                //对于商品表也是将数据赋值到临时的TableBean对象中
                try {
                    BeanUtils.copyProperties(pdBean,value);
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    e.printStackTrace();
                }
            }
        }
        //当两个表的数据都临时存储好之后，将数据写入到最后的封装对象中
        //遍历集合 orderBeans,替换掉每个 orderBean 的 pid 为 pname,然后写出
        for (TableBean orderBean : orderBeans) {
            orderBean.setPname(pdBean.getPname());
            context.write(orderBean,NullWritable.get());
        }

    }
}

 编写driver类

package cn.itjdb.mapreduce.reducejoin;

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;

import java.io.IOException;


public class TableDriver {
    public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
        //1、获取job
        Configuration configuration = new Configuration();
        Job job = Job.getInstance(configuration);

        //2、获取jar包路径
        job.setJarByClass(TableDriver.class);

        //3、关联mapper和reduce
        job.setMapperClass(TableMapper.class);
        job.setReducerClass(TableReduce.class);

        //4、设置map输出kv类型
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(TableBean.class);

        //5、设置最终输出的kv类型
        job.setOutputKeyClass(TableBean.class);
        job.setOutputValueClass(NullWritable.class);

        //6、设置输入路径和输出路径
        FileInputFormat.setInputPaths(job,new Path("D:\\input\\inputtable"));
        FileOutputFormat.setOutputPath(job,new Path("D:\\input\\outputtable"));

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

 结果显示：

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

2、MapJoin

        Map Join 适用于一张表十分小、一张表很大的场景。主要是因为一张小的表可以将其存储在内存中，可以很方便调用。在 Map 端缓存多张表，提前处理业务逻辑，这样增加 Map 端业务，减少 Reduce 端数 据的压力，尽可能的减少数据倾斜。

        步骤：1）在 Mapper 的 setup 阶段，将文件读取到缓存集合中。

        2）在 Driver 驱动类中加载缓存。

案例：数据和ReduceJoin的案例一致。

需求分析：MapJoin 适用于关联表中有小表的情形。

 首先现在driver类中添加缓存文件，方便后续使用。

package cn.itjdb.mapreduce.mapjoin;


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;

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

public class MapJoinDriver {
    public static void main(String[] args) throws IOException, URISyntaxException, ClassNotFoundException, InterruptedException {
        //1、获取job
        Configuration conf = new Configuration();
        Job job = Job.getInstance(conf);

        //2、设置加载jar包
        job.setJarByClass(MapJoinDriver.class);

        //3、关联mapper
        job.setMapperClass(MapJoinMapper.class);

        //4、设置map输出kv类型
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(NullWritable.class);

        //5、设置最终输出kv类型
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(NullWritable.class);

        //加载缓存数据
        job.addCacheFile(new URI("file:///D:/input/inputtable/pd.txt"));
        //map端join的逻辑不需要reduce阶段，因此设置reduceTask数量为0
        job.setNumReduceTasks(0);

        //6、设置输入路径和输出路径
        FileInputFormat.setInputPaths(job,new Path("D:\\input\\inputtable1"));
        FileOutputFormat.setOutputPath(job,new Path("D:\\input\\outputtablemap"));

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

    }
}

编写mapper类（由于后续不需要reduce阶段的计算，因此将ReduceTask的数量设置为0）

package cn.itjdb.mapreduce.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.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URI;
import java.util.HashMap;


public class MapJoinMapper extends Mapper<LongWritable,Text, Text, NullWritable> {
    private HashMap<String, String> pdMap = new HashMap<>();
    private Text outK=new Text();
    @Override
    protected void setup(Context context) throws IOException, InterruptedException {
        //在初始化是加载缓存数据pd.txt,并将数据封装到集合
        URI[] cacheFiles = context.getCacheFiles(); // 获取数据流集合

        获取文件系统对象,并开流
        FileSystem fs=FileSystem.get(context.getConfiguration());
        FSDataInputStream fis=fs.open(new Path(cacheFiles[0]));

        //从流中读取数据
        BufferedReader reader = new BufferedReader(new InputStreamReader(fis, "UTF-8"));

        String line;
        while (StringUtils.isNotEmpty(line=reader.readLine())){
            //切割
            String[] splits = line.split("\t");

            //赋值，将切割的数据赋值给一个集合进行保存
            pdMap.put(splits[0],splits[1]);
        }
        //关流
        IOUtils.closeStream(reader);
    }

    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        //处理order.txt
        String line = value.toString();
        String[] split = line.split("\t");

        //获取pid，通过大表每行数据的 pid,去 pdMap 里面取出 pname
        String pname = pdMap.get(split[1]);  //通过order表中的pid得到商品表中的pname

        //获取订单id和订单数量，封装
        outK.set(split[0]+"\t"+pname+"\t"+split[2]);
        context.write(outK,NullWritable.get());
    }
}

其实，mapper的使用就是将小表的数据从缓存数据中读取到一个集合中在进行对数据的拼接。