大数据框架之一——Hadoop学习第三天
1、MapReduce概述及原理
-
MapReduce是一种分布式计算模型，由Google提出，主要用于搜索领域，解决海量数据的计算问题.
-
MapReduce是分布式运行的，由两个阶段组成：Map和Reduce，Map阶段是一个独立的程序，有很多个节点同时运行，每个节点处理一部分数据。Reduce阶段是一个独立的程序，有很多个节点同时运行，每个节点处理一部分数据【在这先把reduce理解为一个单独的聚合程序即可】.
-
MapReduce框架都有默认实现，用户只需要覆盖map()和reduce()两个函数，即可实现分布式计算，非常简单.
- 这两个函数的形参和返回值都是<key、value>，使用的时候一定要注意构造<k,v>。
2、WordCount计算
2.1常用的Writable实现类
- MapReduce中对应数据格式为Key-Value格式，并且Key和Value都是Writable实现类
2.2MapReduce计算-WordCount
- 主函数入口代码如下
package com.mr.worcount;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.input.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;
import java.io.FileNotFoundException;
import java.io.IOException;
public class WordCount {
public static void main(String[] args) throws IOException, InterruptedException, ClassNotFoundException {
// TODO MapReduce程序入口中的固定写法
// TODO 1.获取Job对象 并设置相关Job任务的名称及入口类
// Job job = new Job();
// job.setJobName("word count");
Configuration conf = new Configuration();
Job job = Job.getInstance(conf, "word count");
// 设置当前main方法所在的入口类
job.setJarByClass(WordCount.class);
// TODO 2.设置自定义的Mapper和Reducer类
job.setMapperClass(WordCountMapper.class);
job.setReducerClass(WordCountReducer.class);
// TODO 3.设置Mapper的KeyValue输出类 和 Reducer的输出类 (最终输出)
job.setMapOutputKeyClass(IntWritable.class);
job.setMapOutputValueClass(IntWritable.class);
job.setOutputKeyClass(IntWritable.class);
job.setOutputValueClass(IntWritable.class);
// 设置ReduceTask的数量为2
job.setNumReduceTasks(2);
// TODO 4.设置数据的输入和输出路径
// org.apache.hadoop.mapreduce.lib.input.TextInputFormat;
// org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;
//在HDFS上进行文件的读取和写出
// TextInputFormat.addInputPath(job,new Path("/data/words.txt"));
// TextOutputFormat.setOutputPath(job,new Path("/api/wordCount"));
// 本地路径
FileSystem fileSystem = FileSystem.get(job.getConfiguration());
Path outPath = new Path("hadoop/out/wordCount");
// Path inpath = new Path("hadoop/data/words.txt");
Path inpath = new Path("hadoop/data/words");
if (!fileSystem.exists(inpath)) {
throw new FileNotFoundException(inpath+"不存在");
// System.out.println(inpath+"不存在");
// System.exit(1);
}
// TextInputFormat.addInputPath(job,inpath);
FileInputFormat.addInputPath(job,inpath);
if (fileSystem.exists(outPath)) {
System.out.println("路径存在，开始删除");
fileSystem.delete(outPath,true);
}
// TextOutputFormat.setOutputPath(job,outPath);
FileOutputFormat.setOutputPath(job,outPath);
// TODO 5.提交任务开始执行
job.waitForCompletion(true);
}
}
- Mapper代码
package com.mr.worcount;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;
import java.io.IOException;
/*
TODO MapTask阶段
自定义类继承Mapper,该Mapper类为一个具体的类，并其中定义了一些泛型
<KEYIN, VALUEIN, KEYOUT, VALUEOUT>
通过之前的学习，知道MapTask阶段需要编写map函数，定义数据处理的逻辑
KEYIN: 表示输入的Key的类型 表示map函数处理的Key类型 变量保存的数据是偏移量
读取数据的位置 字节数的位置非常大，需要使用Long类型 => LongWritable
VALUEIN: 表示输入的Value类型 表示map函数处理的Value类型 表示的是一行字符串数据 String => Text
KEYOUT: 表示输出的Key的类型 根据要处理的数据逻辑来进行定义 => 输出的Key为单词 => Java中的String类型 => Hadoop中的Text
VALUEOUT:表示输出的Value的类型 根据要处理的数据逻辑来进行定义 => 输出的Value为1 => Java中的int类型 => Hadoop中的IntWritable
注意:当数据在Hadoop中进行传递时，需要进行序列化，而Java中的序列化内容多，比较重，导致网络IO开销大
为了计算速度快，Hadoop提供一套新的序列化类型
*/
public class WordCountMapper extends Mapper<LongWritable, Text,Text, IntWritable> {
/**
* map函数中定义了Task任务在Map阶段所做的数据处理任务
* 当前函数中需要对获取到的一行字符串进行按照 空格切分，再将单词遍历 之后再形成 Key为单词 1为Value的数据形式
* TODO 注意：map方法在执行的过程中是一行数据对应调用一次该函数
* @param key 变量保存的数据是偏移量
* @param value 表示的是一行字符串数据 是从文本文件中按行读取出来的
* @param context 表示的是 Mapper.Context的上下文对象，作用是连接 Map阶段和Reduce阶段的桥梁
*/
@Override
protected void map(LongWritable key, Text value, Mapper<LongWritable, Text, Text, IntWritable>.Context context) throws IOException, InterruptedException {
// value遍历中的数据 => hello hadoop
// TODO 获取到的一行字符串进行按照 空格切分
String[] words = value.toString().split(" ");
// TODO 再将单词遍历
for (String word : words) {
// TODO 形成Key为单词 1为Value的数据形式
// context 对象可以将Map阶段生成的数据发送给reduce阶段
context.write(new Text(word),new IntWritable(1));
}
}
}
- Reducer阶段
package com.mr.worcount;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;
import java.io.IOException;
/*
TODO ReduceTask阶段
自定义类继承Reducer,该Reducer类为一个具体的类，并其中定义了一些泛型
<KEYIN, VALUEIN, KEYOUT, VALUEOUT>
Reduce阶段的数据是由Map阶段发送过来的，所以Map阶段输出的类型就是Reduce阶段接收的类型
根据处理逻辑：
KEYIN: Text
VALUEIN: IntWritable
根据数据最终的要求：
KEYOUT, VALUEOUT 表示最终每个单词出现的次数
KEYOUT : Text
VALUEOUT: IntWritable
*/
public class WordCountReducer extends Reducer<Text, IntWritable,Text, IntWritable> {
/**
* reduce函数中定义了 Reduce阶段中要执行的代码逻辑
* 将相同单词的KeyValue数据汇集到一起，再将所有的Value值 1 进行相加 得到最终的结果
* TODO 注意：① 对于reduce函数需要等Mapper阶段执行完成后才能再执行
* ② 对于每个Key会调用一次reduce函数
* ③ 对于Key的处理是存在有先后顺序的 按照字典序进行排序
* @param key 表示map端输出的Key数据 单词
* @param values 类型为Iterable 表示相同Key的Value数据形成的迭代器
* @param context 上下文对象 可以将数据写出到HDFS
* @throws IOException
* @throws InterruptedException
*/
@Override
protected void reduce(Text key, Iterable<IntWritable> values, Reducer<Text, IntWritable, Text, IntWritable>.Context context) throws IOException, InterruptedException {
// 定义num 用于记录单词出现的次数
int num = 0;
// TODO 再将所有的Value值 1 进行相加 得到最终的结果
for (IntWritable value : values) {
num += value.get();
}
context.write(key,new IntWritable(num));
}
}
3、Map Reduce关联分析
3.1案例：针对学生的各科成绩数据进行汇总
①主函数
package com.mr.count;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;
import java.io.FileNotFoundException;
import java.io.IOException;
public class Count {
public static void main(String[] args) throws IOException, InterruptedException, ClassNotFoundException {
// TODO MapReduce程序入口中的固定写法
// TODO 1.获取Job对象 并设置相关Job任务的名称及入口类
// Job job = new Job();
// job.setJobName("word count");
Configuration conf = new Configuration();
Job job = Job.getInstance(conf, "ReduceJoin");
// 设置当前main方法所在的入口类
job.setJarByClass(Count.class);
// TODO 2.设置自定义的Mapper和Reducer类
job.setMapperClass(CountMapper.class);
job.setReducerClass(CountReducer.class);
// TODO 3.设置Mapper的KeyValue输出类 和 Reducer的输出类 (最终输出)
job.setMapOutputKeyClass(Text.class);
job.setMapOutputValueClass(IntWritable.class);
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(IntWritable.class);
// TODO 4.设置数据的输入和输出路径
// 本地路径
FileSystem fileSystem = FileSystem.get(job.getConfiguration());
Path outPath = new Path("hadoop/out/count");
Path inpath = new Path("hadoop/data/score.txt");
if (!fileSystem.exists(inpath)) {
throw new FileNotFoundException(inpath+"不存在");
}
TextInputFormat.addInputPath(job,inpath);
// TextInputFormat.addInputPath(job,inpath);
if (fileSystem.exists(outPath)) {
System.out.println("路径存在，开始删除");
fileSystem.delete(outPath,true);
}
TextOutputFormat.setOutputPath(job,outPath);
// TODO 5.提交任务开始执行
job.waitForCompletion(true);
}
}
②对应的Mapper代码
package com.mr.count;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;
import java.io.IOException;
/*
TODO
在编写代码之前需要先定义数据的处理逻辑
MapTask阶段：
根据读取的一行数据 进行按照，进行切分 获取学生ID和学生成绩 将学生ID作为key 成绩作为Value写出到 Reduce
ReduceTask阶段：
根据相同的学生ID将所有的成绩数据作为values获取到 形成迭代器，再进行遍历求其总和
KEYIN: 表示输入的Key的类型 表示map函数处理的Key类型 变量保存的数据是偏移量
读取数据的位置 字节数的位置非常大，需要使用Long类型 => LongWritable
VALUEIN: 表示输入的Value类型 表示map函数处理的Value类型 表示的是一行字符串数据 String => Text
KEYOUT: 学生ID => 字符串 => Text
VALUEOUT: 各科的成绩 => int => IntWritable
*/
public class CountMapper extends Mapper<LongWritable, Text, Text, IntWritable> {
/**
* map函数中定义了Task任务在Map阶段所做的数据处理任务
* 根据读取的一行数据 进行按照，进行切分 获取学生ID和学生成绩 将学生ID作为key 成绩作为Value写出到 Reduce
*
* @param key 变量保存的数据是偏移量
* @param value 表示的是一行字符串数据 是从文本文件中按行读取出来的
* @param context 表示的是 Mapper.Context的上下文对象，作用是连接 Map阶段和Reduce阶段的桥梁
*/
@Override
protected void map(LongWritable key, Text value, Mapper<LongWritable, Text, Text, IntWritable>.Context context) throws IOException, InterruptedException {
String[] columns = value.toString().split(",");
if (columns.length == 3) {
String id = columns[0];
String score = columns[2];
context.write(new Text(id),new IntWritable(Integer.valueOf(score)));
}
}
}
③Reducer阶段
package com.mr.count;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;
import java.io.IOException;
/*
TODO ReduceTask阶段
自定义类继承Reducer,该Reducer类为一个具体的类，并其中定义了一些泛型
<KEYIN, VALUEIN, KEYOUT, VALUEOUT>
Reduce阶段的数据是由Map阶段发送过来的，所以Map阶段输出的类型就是Reduce阶段接收的类型
根据处理逻辑：
KEYIN: Text
VALUEIN: IntWritable
根据数据最终的要求：
KEYOUT, VALUEOUT 表示最终每个单词出现的次数
KEYOUT : Text
VALUEOUT: IntWritable
*/
public class CountReducer extends Reducer<Text, IntWritable,Text, IntWritable> {
/**
* reduce函数中定义了 Reduce阶段中要执行的代码逻辑
* 根据相同的学生ID将所有的成绩数据作为values获取到 形成迭代器，再进行遍历求其总和
* @param key 表示map端输出的Key数据 学生ID
* @param values 类型为Iterable 表示相同学生ID的成绩数据
* @param context 上下文对象 可以将数据写出到HDFS
* @throws IOException
* @throws InterruptedException
*/
@Override
protected void reduce(Text key, Iterable<IntWritable> values, Reducer<Text, IntWritable, Text, IntWritable>.Context context) throws IOException, InterruptedException {
int totalScore= 0;
for (IntWritable score : values) {
totalScore += score.get();
}
context.write(key,new IntWritable(totalScore));
}
}
3.2ReduceJoin
- 在map阶段，map函数同时读取两个文件File1和File2，注意区分的方法
①主入口
package com.mr.reduceJoin;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;
import java.io.FileNotFoundException;
import java.io.IOException;
public class ReduceJoin {
public static void main(String[] args) throws IOException, InterruptedException, ClassNotFoundException {
// TODO MapReduce程序入口中的固定写法
// TODO 1.获取Job对象 并设置相关Job任务的名称及入口类
// Job job = new Job();
// job.setJobName("word count");
Configuration conf = new Configuration();
Job job = Job.getInstance(conf, "ReduceJoin");
// 设置当前main方法所在的入口类
job.setJarByClass(ReduceJoin.class);
// TODO 2.设置自定义的Mapper和Reducer类
job.setMapperClass(ReduceJoinMapper.class);
job.setReducerClass(ReduceJoinReducer.class);
// TODO 3.设置Mapper的KeyValue输出类 和 Reducer的输出类 (最终输出)
job.setMapOutputKeyClass(Text.class);
job.setMapOutputValueClass(Text.class);
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(Text.class);
// TODO 4.设置数据的输入和输出路径
// 本地路径
FileSystem fileSystem = FileSystem.get(job.getConfiguration());
Path outPath = new Path("hadoop/out/reducejoin");
// TODO 对输入路径添加了学生基本信息数据和总分数据
Path studentInpath = new Path("hadoop/data/students.txt");
Path totalScoreInpath = new Path("hadoop/out/count");
if (!fileSystem.exists(studentInpath)) {
throw new FileNotFoundException(studentInpath+"不存在");
}
TextInputFormat.addInputPath(job,studentInpath);
if (!fileSystem.exists(totalScoreInpath)) {
throw new FileNotFoundException(totalScoreInpath+"不存在");
}
TextInputFormat.addInputPath(job,totalScoreInpath);
if (fileSystem.exists(outPath)) {
System.out.println("路径存在，开始删除");
fileSystem.delete(outPath,true);
}
TextOutputFormat.setOutputPath(job,outPath);
// TODO 5.提交任务开始执行
job.waitForCompletion(true);
}
}
②MapTask阶段
package com.mr.reduceJoin;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;
import java.io.IOException;
/*
TODO
在编写代码之前需要先定义数据的处理逻辑
MapTask阶段
① 对于MapTask需要对不同文件的数据进行判断
② 将读取到的字符串进行切分处理，将学生ID作为Key，其他信息作为Value写出到ReduceTask阶段
其中其他信息包含： 学生的所有基本信息和 学生的成绩数据 两类
注意：
对于Mapper阶段的输出KeyValue类型为 Text Text
ReduceTask阶段
① 接收的数据类型，就是MapTask阶段输出的数据类型
② 针对相同Key的Value数据进行判断是否为成绩数据或者基本信息数据
③ 如果判断出来，再拼接成一个整的字符串，再进行输出
*/
public class ReduceJoinMapper extends Mapper<LongWritable, Text, Text, Text> {
/**
* 通过Debug可以看到对于多个文件数据，先读取students.txt数据再读取 count的结果数据
*/
@Override
protected void map(LongWritable key, Text value, Mapper<LongWritable, Text, Text, Text>.Context context) throws IOException, InterruptedException {
String readLine = value.toString();
if (readLine.contains(",")) {
String[] columns = readLine.split(",");
if (columns.length == 5){
String id = columns[0];
String name = columns[1];
String age = columns[2];
String gender = columns[3];
String clazz = columns[4];
context.write(new Text(id),new Text(name+","+age+","+gender+","+clazz));
}
}else {
String[] columns = readLine.split("\t");
if (columns.length == 2){
String id = columns[0];
String score = columns[1];
context.write(new Text(id),new Text(score));
}
}
}
}
③ReduceTask阶段
package com.mr.reduceJoin;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;
import java.io.IOException;
/*
TODO ReduceTask阶段
自定义类继承Reducer,该Reducer类为一个具体的类，并其中定义了一些泛型
<KEYIN, VALUEIN, KEYOUT, VALUEOUT>
Reduce阶段的数据是由Map阶段发送过来的，所以Map阶段输出的类型就是Reduce阶段接收的类型
根据处理逻辑：
KEYIN: Text
VALUEIN: IntWritable
根据数据最终的要求：
KEYOUT, VALUEOUT 表示最终每个单词出现的次数
KEYOUT : Text
VALUEOUT: IntWritable
*/
public class ReduceJoinReducer extends Reducer<Text, Text,Text, Text> {
/**
* ReduceJoin 是指数据关联是产生再Reduce阶段
*/
@Override
protected void reduce(Text key, Iterable<Text> values, Reducer<Text, Text, Text, Text>.Context context) throws IOException, InterruptedException {
String info ="";
String score ="";
for (Text value : values) {
if (!value.toString().contains(",")){
// 当长度为1表示学生的成绩数据
score = value.toString();
}else {
// 学生的基本信息数据
info = value.toString();
}
}
context.write(key,new Text(info+","+score));
}
}
4、MapReduce过滤
- 在MapReduce过程中可以根据判断逻辑选择适当的数据进行写出，同时MapReduce过程中允许只存在有Map过程
4.1过滤出总分大于450分的同学
①主函数
package com.mr.filter.more450;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
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.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;
import java.io.FileNotFoundException;
import java.io.IOException;
public class FilterMore450 {
public static void main(String[] args) throws IOException, InterruptedException, ClassNotFoundException {
// TODO MapReduce程序入口中的固定写法
// TODO 1.获取Job对象 并设置相关Job任务的名称及入口类
// Job job = new Job();
// job.setJobName("word count");
Configuration conf = new Configuration();
Job job = Job.getInstance(conf, "FilterMore450");
// 设置当前main方法所在的入口类
job.setJarByClass(FilterMore450.class);
// TODO 2.设置自定义的Mapper和Reducer类
job.setMapperClass(FilterMore450Mapper.class);
// TODO 3.设置Mapper的KeyValue输出类 (最终输出)
job.setMapOutputKeyClass(Text.class);
// job.setMapOutputValueClass(Text.class);
job.setMapOutputValueClass(NullWritable.class);
job.setOutputKeyClass(Text.class);
// job.setOutputValueClass(Text.class);
job.setOutputValueClass(NullWritable.class);
// TODO 4.设置数据的输入和输出路径
// 本地路径
FileSystem fileSystem = FileSystem.get(job.getConfiguration());
Path outPath = new Path("hadoop/out/filterMore450");
Path inpath = new Path("hadoop/out/reducejoin");
if (!fileSystem.exists(inpath)) {
throw new FileNotFoundException(inpath+"不存在");
}
TextInputFormat.addInputPath(job,inpath);
if (fileSystem.exists(outPath)) {
System.out.println("路径存在，开始删除");
fileSystem.delete(outPath,true);
}
TextOutputFormat.setOutputPath(job,outPath);
// TODO 5.提交任务开始执行
job.waitForCompletion(true);
}
}
②MapTask阶段
package com.mr.filter.more450;
import org.apache.hadoop.io.IntWritable;
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.IOException;
/*
TODO
在编写代码之前需要先定义数据的处理逻辑
MapTask阶段：
可以直接读取ReduceJoin的结果数据
注意：
① 对于MapReduce可以只有Mapper阶段
② 对于输出的数据，可以只有Key 对于Value的数据类型从可以使用 NullWritable
*/
public class FilterMore450Mapper extends Mapper<LongWritable, Text, Text, NullWritable> {
/**
*
*/
@Override
protected void map(LongWritable key, Text value, Mapper<LongWritable, Text, Text, NullWritable>.Context context) throws IOException, InterruptedException {
// 1500100008 符半双,22,女,理科六班,363
String oneLine = value.toString();
String[] split = oneLine.split("\t");
String id = split[0];
Integer score = Integer.valueOf(split[1].split(",")[4]);
if (score > 450){
context.write(new Text(id+","+split[1]),NullWritable.get());
}
}
}
4.2对于各班级中的学生总分进行排序，要求取出各班级中总分前三名学生
①主入口
package com.mr.groupby;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
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.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;
import java.io.FileNotFoundException;
import java.io.IOException;
public class Top3 {
public static void main(String[] args) throws IOException, InterruptedException, ClassNotFoundException {
// TODO MapReduce程序入口中的固定写法
// TODO 1.获取Job对象 并设置相关Job任务的名称及入口类
Configuration conf = new Configuration();
Job job = Job.getInstance(conf, "Sort");
// 设置当前main方法所在的入口类
job.setJarByClass(Top3.class);
// TODO 2.设置自定义的Mapper和Reducer类
job.setMapperClass(Top3Mapper.class);
job.setReducerClass(Top3Reducer.class);
// TODO 3.设置Mapper的KeyValue输出类 和 Reducer的输出类 (最终输出)
job.setMapOutputKeyClass(Text.class);
job.setMapOutputValueClass(Text.class);
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(NullWritable.class);
// TODO 4.设置数据的输入和输出路径
// 本地路径
FileSystem fileSystem = FileSystem.get(job.getConfiguration());
Path outPath = new Path("hadoop/out/top3");
Path inpath = new Path("hadoop/out/reducejoin");
if (!fileSystem.exists(inpath)) {
throw new FileNotFoundException(inpath+"不存在");
}
TextInputFormat.addInputPath(job,inpath);
if (fileSystem.exists(outPath)) {
System.out.println("路径存在，开始删除");
fileSystem.delete(outPath,true);
}
TextOutputFormat.setOutputPath(job,outPath);
// TODO 5.提交任务开始执行
job.waitForCompletion(true);
}
}
②MapTask阶段
package com.mr.groupby;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;
import java.io.IOException;
/*
TODO
在编写代码之前需要先定义数据的处理逻辑
对于各班级中的学生总分进行排序，要求取出各班级中总分前三名学生
MapTask阶段：
① 读取ReduceJoin的处理结果，并对数据进行提取
② 按照学生的班级信息，对班级作为Key,整行数据作为Value写出到 ReduceTask 端
ReduceTask阶段：
① 接收到整个班级中的所有学生信息并将该数据存放在迭代器中
*/
public class Top3Mapper extends Mapper<LongWritable, Text, Text, Text> {
@Override
protected void map(LongWritable key, Text value, Mapper<LongWritable, Text, Text, Text>.Context context) throws IOException, InterruptedException {
// 1500100009 沈德昌,21,男,理科一班,251 => 表示读取到的数据
String[] split = value.toString().split("\t");
if (split.length == 2) {
String otherInfo = split[1];
String[] columns = otherInfo.split(",");
if (columns.length == 5) {
String clazz = columns[3];
context.write(new Text(clazz), value);
}
}
}
}
③ReduceTask阶段
package com.mr.groupby;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
/*
TODO ReduceTask阶段
自定义类继承Reducer,该Reducer类为一个具体的类，并其中定义了一些泛型
<KEYIN, VALUEIN, KEYOUT, VALUEOUT>
Reduce阶段的数据是由Map阶段发送过来的，所以Map阶段输出的类型就是Reduce阶段接收的类型
根据处理逻辑：
KEYIN: Text
VALUEIN: IntWritable
根据数据最终的要求：
KEYOUT, VALUEOUT 表示最终每个单词出现的次数
KEYOUT : Text
VALUEOUT: IntWritable
*/
public class Top3Reducer extends Reducer<Text, Text,Text, NullWritable> {
/**
* 对一个班级中所有的学生成绩进行排序 =>
* 1.将数据存储在一个容器中
* 2.对容器中数据进行排序操作
* 对排序的结果进行取前三
* @param key 表示班级信息
* @param values 一个班级中所有的学生数据
* @param context
* @throws IOException
* @throws InterruptedException
*/
@Override
protected void reduce(Text key, Iterable<Text> values, Reducer<Text, Text, Text, NullWritable>.Context context) throws IOException, InterruptedException {
// 1500100009 沈德昌,21,男,理科一班,251
List<Stu> stus = new ArrayList<>();
for (Text stu : values) {
String[] split = stu.toString().split("\t");
String[] columns = split[1].split(",");
stus.add(new Stu(split[0],columns[0],Integer.valueOf(columns[1]),columns[2],columns[3],Integer.valueOf(columns[4])));
}
// 对List中的数据进行排序操作
Collections.sort(
stus,
new Comparator<Stu>() {
@Override
public int compare(Stu o1, Stu o2) {
int compareScore = o1.score - o2.score;
return - compareScore > 0 ? 1: (compareScore == 0? o1.id.compareTo(o2.id):-1);
}
}
);
// 对排序的结果进行遍历
for (int i = 0; i < 3; i++) {
context.write(new Text(stus.get(i).toString()+","+(i+1)),NullWritable.get());
}
}
}
④Student类
package com.mr.groupby;
public class Stu {
String id;
String name;
int age;
String gender;
String clazz;
int score;
public Stu(String id, String name, int age, String gender, String clazz, int score) {
this.id = id;
this.name = name;
this.age = age;
this.gender = gender;
this.clazz = clazz;
this.score = score;
}
@Override
public String toString() {
return id +
", " + name +
", " + age +
", " + gender +
", " + clazz +
", " + score;
}
}
