【MapReduce】扩展案例 ---- TopN（求取数据集前N名）
原创
©著作权归作者所有：来自51CTO博客作者阿呆小记的原创作品，请联系作者获取转载授权，否则将追究法律责任
文章目录
TopN（求取数据集前N名）
需求
对之前统计的上、下行流量总值输出结果进行加工，输出流量使用量在前10的用户信息
（1）输入数据
（2）输出数据
返回顶部
需求分析
返回顶部
代码实现
① Bean类
- 创建Bean类，封装上下行、总流量对象
- 创建无参构造方法 — 供反序列化使用
- 重写序列化、反序列化方法
- 重写toString()方法
- 继承自WritableComparable，重写compareTo()方法，自定义排序
- 自定义方法统计总流量
package 第七章_MR扩展案例.TopN;
import org.apache.hadoop.io.WritableComparable;
import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
public class TopNBean implements WritableComparable<TopNBean> {
private long upFlow;
private long downFlow;
private long sumFlow;
/**
* 无参构造方法
*/
public TopNBean() {
}
/**
* 重写比较方法
* @param bean
* @return
*/
@Override
public int compareTo(TopNBean bean) {
int result;
if (sumFlow > bean.getSumFlow()) {
result = -1;
} else if (sumFlow < bean.getSumFlow()) {
result = 1;
} else {
result = 0;
}
return result;
}
/**
* 序列化
*
* @param dataOutput
* @throws IOException
*/
@Override
public void write(DataOutput dataOutput) throws IOException {
dataOutput.writeLong(upFlow);
dataOutput.writeLong(downFlow);
dataOutput.writeLong(sumFlow);
}
/**
* 反序列化
*
* @param dataInput
* @throws IOException
*/
@Override
public void readFields(DataInput dataInput) throws IOException {
upFlow = dataInput.readLong();
downFlow = dataInput.readLong();
sumFlow = dataInput.readLong();
}
@Override
public String toString() {
return upFlow + "\t"+ downFlow + "\t"+ sumFlow;
}
/**
* set\get
*
* @return
*/
public long getUpFlow() {
return upFlow;
}
public void setUpFlow(long upFlow) {
this.upFlow = upFlow;
}
public long getDownFlow() {
return downFlow;
}
public void setDownFlow(long downFlow) {
this.downFlow = downFlow;
}
public long getSumFlow() {
return sumFlow;
}
public void setSumFlow(long sumFlow) {
this.sumFlow = sumFlow;
}
public void set(long upFlow1, long downFlow1) {
upFlow = upFlow1;
downFlow = downFlow1;
sumFlow = upFlow+downFlow;
}
}
返回顶部
② Mapper 阶段
- 定义TreeMap集合
- 读取数据、拆分、封装Bean对象
- 以Bean对象为key，号码为value键值对存入TreeMap集合，按照自定义排序进行排序
- 存入同时判断集合大小，以达到提取前n名的效果
- 遍历集合写出到Reducer端
package 第七章_MR扩展案例.TopN;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;
import java.io.IOException;
import java.util.Iterator;
import java.util.TreeMap;
public class TopNMapper extends Mapper<LongWritable, Text, TopNBean, Text> {
// 1.定义一个treeMap作为存储数据的容器（自动按照key排序）
private TreeMap<TopNBean, Text> treeMap = new TreeMap<>();
TopNBean k;
Text v = new Text();
@Override
protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
// 13470253144 180 180 360
// 13509468723 7335 110349 117684
k = new TopNBean();
// 1.读取一行数据
String line = value.toString();
// 2.拆分
String[] fields = line.split("\t");
// 3.封装Beand对象
long upFlow = Long.parseLong(fields[1]);
long downFlow = Long.parseLong(fields[2]);
long sumFlow = Long.parseLong(fields[3]);
k.setUpFlow(upFlow);
k.setDownFlow(downFlow);
k.setSumFlow(sumFlow);
String phone = fields[0];
v.set(phone);
// 4.向集合中添加元素
treeMap.put(k, v);
// 5.限制TreeMap的数量
if (treeMap.size() > 10) {
treeMap.remove(treeMap.lastKey()); // 删除最后一个
}
}
/**
* 重写cleanUp，统一释放资源
*
* @param context
* @throws IOException
* @throws InterruptedException
*/
@Override
protected void cleanup(Context context) throws IOException, InterruptedException {
// 6 遍历treeMap集合，输出数据
Iterator<TopNBean> bean = treeMap.keySet().iterator();
while (bean.hasNext()) {
TopNBean k = bean.next();
context.write(k, treeMap.get(k));
}
}
}
☠ 注意
// 1.定义一个treeMap作为存储数据的容器（自动按照key排序）
private TreeMap<TopNBean, Text> treeMap = new TreeMap<>();
TopNBean k;
Text v = new Text();
@Override
protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
// 创建Bean对象
k = new TopNBean();
// 1.读取一行数据
// 2.拆分
// 3.封装Beand对象
......
v.set(phone);
// 4.向集合中添加元素
treeMap.put(k, v);
这个地方要重点关注，在创建Bean对象k的时候要写在map()方法内部，它是针对每一次的map(),也就是每一行数据而言的。当你每读取一行数据，就会封装一个Bean对象(需要内存地址不同)，然后写入TreeMap集合；否则定义在map()外面，这样k(Bean对象)就是全局变量，内存地址不会改变，针对每一行数据而言用的就是同一个Bean对象，在封装的时候对原有的Bean对象只是重新赋值，添加到TreeMap集合中的元素也始终只有一个，最终结果只会输出最后一行数据。
返回顶部
③ Reducer 阶段
- 拉取Mapper端数据集，同样创建TreeMapper集合
- 遍历Mapper端数据集存入TreeMap集合，筛选前10条
- 遍历TreeMap集合输出结果
package 第七章_MR扩展案例.TopN;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;
import java.io.IOException;
import java.util.Iterator;
import java.util.TreeMap;
public class TopNReducer extends Reducer<TopNBean, Text, Text, TopNBean> {
// 定义一个TreeMap作为存储数据的容器（天然按key排序）
TreeMap<TopNBean, Text> flowMap = new TreeMap<>();
@Override
protected void reduce(TopNBean key, Iterable<Text> values, Context context) throws IOException, InterruptedException {
for (Text value : values) {
TopNBean bean = new TopNBean();
bean.set(key.getDownFlow(), key.getUpFlow());
// 1 向treeMap集合中添加数据
flowMap.put(bean, new Text(value));
// 2 限制TreeMap数据量，超过10条就删除掉流量最小的一条数据
if (flowMap.size() > 10) {
// flowMap.remove(flowMap.firstKey());
flowMap.remove(flowMap.lastKey());
}
}
}
@Override
protected void cleanup(Reducer<TopNBean, Text, Text, TopNBean>.Context context) throws IOException, InterruptedException {
// 3 遍历集合，输出数据
Iterator<TopNBean> it = flowMap.keySet().iterator();
TopNBean key;
while (it.hasNext()) {
key = it.next();
Text value = flowMap.get(key);
context.write(value, key);
}
}
}
Reducer阶段也是同样如此，他也要像Mapper阶段作相同的处理。原因是，数据集在开始处理之前会进行Split切片，切片的数量决定了MapTask开启的数量，本案例数据量很小，达不到切片的地步。假设文件200M，那就要分为两片，同时开启两个MapTask，每一个MapTask都会执行一次map()方法，都会各自写出各自那片数据集中的前10条数据，由于没有设定分区，所以默认为1。这样一来，Reducer端在去拉取数据的时候归并后就会有20条数据，但我们最终的目的是输出前10条，显然Reducer端需要读数据集再次进行处理。
返回顶部
④ Driver 阶段
package 第七章_MR扩展案例.TopN;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
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 TopNDriver {
public static void main(String[] args) {
Job job = null;
Configuration conf = new Configuration();
try {
// 获取job对象
job = Job.getInstance(conf);
// 配置
job.setMapperClass(TopNMapper.class);
job.setReducerClass(TopNReducer.class);
job.setJarByClass(TopNDriver.class);
job.setMapOutputKeyClass(TopNBean.class);
job.setMapOutputValueClass(Text.class);
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(TopNBean.class);
// 设置输入输出路径
FileInputFormat.setInputPaths(job, new Path("G:\\Projects\\IdeaProject-C\\MapReduce\\src\\main\\java\\第二章_Hadoop序列化\\output"));
FileOutputFormat.setOutputPath(job, new Path("G:\\Projects\\IdeaProject-C\\MapReduce\\src\\main\\java\\第七章_MR扩展案例\\TopN\\output1"));
// 提交job
boolean result = job.waitForCompletion(true);
System.exit(result ? 0 : 1);
} catch (Exception e) {
e.printStackTrace();
}
}
}
返回顶部
总结
首先我们来总结一下MapReduce的整体流程：
在本案例中，并没有涉及到分区，而是在map端封装好数据后，以自定义排好序的Bean对象为key,号码为value写入缓存区。在Reducer端拉取数据的时候，按照key进行分组（系统自动进行），相同的key进入同一个reduce()方法，在reduce方法内部遍历key的值，将其存入集合自动排序，最终形成不同Bean对象(不同key)组成的TreeMap集合，且排序筛选出前10名，输出。
返回顶部
