Hadoop中Join多种应用
总结：
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
| id |
pid |
amount |
| 1001 |
01 |
1 |
| 1002 |
02 |
2 |
| 1003 |
03 |
3 |
| 1004 |
01 |
4 |
| 1005 |
02 |
5 |
| 1006 |
03 |
6 |
表商品信息表t_product
| pid |
pname |
| 01 |
小米 |
| 02 |
华为 |
| 03 |
格力 |
将商品信息表中数据根据商品pid合并到订单数据表中。
表最终数据形式
| id |
pname |
amount |
| 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
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
@Override protected void reduce(Text key, Iterable
// 1准备存储订单的集合 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 |
5．总结
3 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"));
4 Map Join案例实操
表4-4 订单数据表t_order
| id |
pid |
amount |
| 1001 |
01 |
1 |
| 1002 |
02 |
2 |
| 1003 |
03 |
3 |
| 1004 |
01 |
4 |
| 1005 |
02 |
5 |
| 1006 |
03 |
6 |
表4-5 商品信息表t_product
| pid |
pname |
| 01 |
小米 |
| 02 |
华为 |
| 03 |
格力 |
将商品信息表中数据根据商品pid合并到订单数据表中。
表4-6 最终数据形式
| id |
pname |
amount |
| 1001 |
小米 |
1 |
| 1004 |
小米 |
4 |
| 1002 |
华为 |
2 |
| 1005 |
华为 |
5 |
| 1003 |
格力 |
3 |
| 1006 |
格力 |
6 |
2．需求分析
MapJoin适用于关联表中有小表的情形
3．实现代码
（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
Map
@Override protected void setup(Mapper
// 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()); } } |