MapReduce多个作业协调处理

一：背景

当数据来源不同的时候，比如用户表在MYSQL数据库中，而销售表在HDFS中，我们可以启动多个作业来依次处理这些数据源。

二：技术实现

#需求

#用户表user在MYSQL数据库中，数据如下：

1. 1 liaozhongmin
2. 2 lavimer
3. 3 liaozemin

#销售表user_data在HDFS中，数据如下：

1. 1 12
2. 2 28
3. 2 36
4. 3 88

#我们现在的需求是要统计每个用户的销售情况，结果应该如下显示：

1. 1 liaozhongmin 12
2. 2 lavimer 64
3. 3 liaozemin 88

代码实现：

MultiJob1.java从数据库中读取数据并进行处理：

1. public class MultiJob1 {
3. public static class Step1Mapper extends Mapper<LongWritable, User, Text, Text>{
4. //创建输出的key
5. private Text outKey = new Text();
6. private Text outValue = new Text();
7. protected void map(LongWritable key, User value, Mapper<LongWritable, User, Text, Text>.Context context) throws IOException, InterruptedException {
8. //设置key
9. outKey.set(String.valueOf(value.getId()));
10. //设置写出去的value
11. outValue.set(value.getName());
13. //把结果写出去
14. context.write(outKey, outValue);
15. }
16. }
18. public static class Step1Reducer extends Reducer<Text, Text, Text, Text>{
19. @Override
20. protected void reduce(Text key, Iterable<Text> values, Reducer<Text, Text, Text, Text>.Context context) throws IOException, InterruptedException {
21. for (Text val : values){
22. context.write(key, val);
23. }
24. }
25. }
27. /**
28. * 运行job的方法
29. * @param path
30. */
31. public static void run(Map<String, String> path){
32. try {
33. //创建配置信息
34. Configuration conf = new Configuration();
36. //通过conf创建数据库配置信息
37. DBConfiguration.configureDB(conf, "com.mysql.jdbc.Driver", "jdbc:mysql://liaozhongmin:3306/myDB", "root", "134045");
39. //从map集合中取出输出路径
40. String step1OutPath = path.get( "step1Output");
42. //创建文件系统
43. FileSystem fileSystem = FileSystem.get( new URI(step1OutPath), conf);
45. //如果输出目录存在就删除
46. if (fileSystem.exists( new Path(step1OutPath))){
47. fileSystem.delete( new Path(step1OutPath), true);
48. }
50. //创建任务
51. Job job = new Job(conf,MultiJob1.class.getName());
53. //1.1 设置输入数据格式化的类和设置数据来源
54. job.setInputFormatClass(DBInputFormat.class);
55. DBInputFormat.setInput(job, User.class, "user", null, null, new String[]{ "id", "name"});
57. //1.2 设置自定义的Mapper类和Mapper输出的key和value的类型
58. job.setMapperClass(Step1Mapper.class);
59. job.setMapOutputKeyClass(Text.class);
60. job.setMapOutputValueClass(Text.class);
62. //1.3 设置分区和reduce数量(reduce的数量和分区的数量对应，因为分区只有一个，所以reduce的个数也设置为一个)
63. job.setPartitionerClass(HashPartitioner.class);
64. job.setNumReduceTasks( 1);
66. //1.4 排序
67. //1.5 归约
68. //2.1 Shuffle把数据从Map端拷贝到Reduce端
69. //job.setCombinerClass(Step1Reducer.class);
70. //2.2 指定Reducer类和输出key和value的类型
71. job.setReducerClass(Step1Reducer.class);
72. job.setOutputKeyClass(Text.class);
73. job.setOutputValueClass(Text.class);
75. //2.3 指定输出的路径和设置输出的格式化类
76. FileOutputFormat.setOutputPath(job, new Path(step1OutPath));
77. job.setOutputFormatClass(TextOutputFormat.class);
79. //提交作业 然后关闭虚拟机正常退出
80. job.waitForCompletion( true);
82. } catch (Exception e) {
83. e.printStackTrace();
84. }
85. }
86. }

MultiJob2.java从HDFS中读取数据并且和第一个Job处理后的结果进行合并：

1. public class MultiJob2 {
3. // 定义一个输入路径用于判断当前处理的是来自哪里的文件
4. private static String FILE_PATH = "";
6. public static class Step2Mapper extends Mapper<LongWritable, Text, Text, Text> {
8. protected void map(LongWritable key, Text value, Mapper<LongWritable, Text, Text, Text>.Context context) throws IOException, InterruptedException {
10. // 获取文件的输入路径
11. FileSplit fileSplit = (FileSplit) context.getInputSplit();
12. FILE_PATH = fileSplit.getPath().toString();
14. // 获取输入行记录
15. String line = value.toString();
16. // 抛弃无效记录(这里最好使用计数器统计一下无效记录)
17. if (line == null || line.equals( "")) {
18. return;
19. }
20. // 处理来自数据库中的中间结果
21. if (FILE_PATH.contains( "part")) {
22. // 按制表符进行切割
23. String[] values = line.split( "\t");
24. // 当数组长度小于2的时候，视为无效记录
25. if (values.length < 2) {
26. return;
27. }
29. // 获取id和name
30. String id = values[ 0];
31. String name = values[ 1];
32. // 把结果写出去
33. context.write( new Text(id), new Text(name));
34. } else if (FILE_PATH.contains( "user_data")) {
35. // 按制表符进行切割
36. String[] values = line.split( "\t");
37. // 当数组长度小于2的时候，视为无效记录
38. if (values.length < 2) {
39. return;
40. }
42. // 获取id和grade
43. String id = values[ 0];
44. String score = values[ 1];
45. // 把结果写出去
46. context.write( new Text(id), new Text(score));
47. }
49. }
50. }
52. public static class Step2Reducer extends Reducer<Text, Text, Text, Text> {
53. @Override
54. protected void reduce(Text key, Iterable<Text> values, Reducer<Text, Text, Text, Text>.Context context) throws IOException, InterruptedException {
57. // 用来存放来自数据库的中间结果
58. Vector<String> vectorDB = new Vector<String>();
59. // 用来存放来自HDFS中处理后的结果
60. Vector<String> vectorHDFS = new Vector<String>();
61. // 迭代数据键对应的数据添加到相应Vector中
62. for (Text val : values) {
63. if (val.toString().startsWith( "db#")) {
64. vectorDB.add(val.toString().substring( 3));
65. } else if (val.toString().startsWith( "hdfs#")) {
66. vectorHDFS.add(val.toString().substring( 5));
67. }
68. }
70. // 获取两个Vector集合的长度
71. int sizeA = vectorDB.size();
72. int sizeB = vectorHDFS.size();
73. // 做笛卡尔积
74. for ( int i = 0; i < sizeA; i++) {
75. for ( int j = 0; j < sizeB; j++) {
76. context.write( new Text(key), new Text(vectorDB.get(i) + "\t" + vectorHDFS.get(j)));
77. }
78. }
79. }
80. }
82. /**
83. * 自定义Combiner
84. *
85. * @author 廖钟民 time : 2015年1月25日下午1:39:51
86. * @version
87. */
88. public static class Step2Combiner extends Reducer<Text, Text, Text, Text> {
89. @Override
90. protected void reduce(Text key, Iterable<Text> values, Reducer<Text, Text, Text, Text>.Context context) throws IOException, InterruptedException {
92. int sum = 0;
93. //处理来自数据库中的数据
94. if (FILE_PATH.contains( "part")) {
95. for (Text val : values) {
96. context.write(key, new Text( "db#" + val.toString()));
97. }
99. } else { //处理来自HDFS中的数据
100. for (Text val : values) {
101. sum += Integer.parseInt(val.toString());
102. }
103. context.write(key, new Text( "hdfs#" + String.valueOf(sum)));
104. }
106. }
107. }
109. public static void run(Map<String, String> paths) {
110. try {
111. // 创建配置信息
112. Configuration conf = new Configuration();
114. // 从Map集合中获取输入输出路径
115. String step2Input1 = paths.get( "step2Input1");
116. String step2Input2 = paths.get( "step2Input2");
117. String step2Output = paths.get( "step2Output");
118. // 创建文件系统
119. FileSystem fileSystem = FileSystem.get( new URI(step2Output), conf);
120. // 如果输出目录存在，我们就删除
121. if (fileSystem.exists( new Path(step2Output))) {
122. fileSystem.delete( new Path(step2Output), true);
123. }
125. // 创建任务
126. Job job = new Job(conf, MultiJob2.class.getName());
128. // 1.1 设置输入目录和设置输入数据格式化的类
129. FileInputFormat.addInputPath(job, new Path(step2Input1));
130. FileInputFormat.addInputPath(job, new Path(step2Input2));
131. job.setInputFormatClass(TextInputFormat.class);
133. //1.2 设置自定义Mapper类和设置map函数输出数据的key和value的类型
134. job.setMapperClass(Step2Mapper.class);
135. job.setMapOutputKeyClass(Text.class);
136. job.setMapOutputValueClass(Text.class);
138. // 1.3 设置分区和reduce数量(reduce的数量，和分区的数量对应，因为分区为一个，所以reduce的数量也是一个)
139. job.setPartitionerClass(HashPartitioner.class);
140. job.setNumReduceTasks( 1);
142. // 1.4 排序
143. // 1.5 归约
144. job.setCombinerClass(Step2Combiner.class);
146. // 2.1 Shuffle把数据从Map端拷贝到Reduce端。
147. // 2.2 指定Reducer类和输出key和value的类型
148. job.setReducerClass(Step2Reducer.class);
149. job.setOutputKeyClass(Text.class);
150. job.setOutputValueClass(Text.class);
152. // 2.3 指定输出的路径和设置输出的格式化类
153. FileOutputFormat.setOutputPath(job, new Path(step2Output));
154. job.setOutputFormatClass(TextOutputFormat.class);
156. // 提交作业 退出
157. job.waitForCompletion( true);
159. } catch (Exception e) {
160. e.printStackTrace();
161. }
162. }
163. }

MultiJobTest.java作业调度控制类：

1. public class MultiJobTest {
3. //定义HDFS的路径
4. public static final String HDFS = "hdfs://liaozhongmin:9000";
7. public static void main(String[] args) {
8. //定义一个map集合用于存储操作参数
9. Map<String, String> paths = new HashMap<String, String>();
11. //存储第一步的输出路径(第一步是从数据库中去取数据，没有输入路径)
12. paths.put( "step1Output", HDFS + "/step1_Out");
14. //存储第二部的输入路径(第二个参数是多参数输入的)
15. paths.put( "step2Input1", HDFS + "/step2_inpath/user_data");
16. paths.put( "step2Input2", HDFS + "/step1_Out/part-*");
17. paths.put( "step2Output", HDFS + "/step2_out");
19. //依次运行job
20. MultiJob1.run(paths);
21. MultiJob2.run(paths);
23. System.exit( 0);
24. }
26. public static JobConf config(){
27. //创建配置
28. JobConf conf = new JobConf(MultiJobTest.class);
29. conf.setJobName( "MultiJobTest");
31. //设置配置文件
32. /*conf.addResource("classpath:/hadoop/core-site.xml");
33. conf.addResource("classpath:/hadoop/hdfs-site.xml");
34. conf.addResource("classpath:/hadoop/mapred-site.xml");*/
36. conf.set( "io.sort.mb", "1024");
38. return conf;
39. }
40. }

程序运行的结果如下：

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/lzm1340458776/article/details/43114611