Hadoop: MapReduce2多个job串行处理

时间:2022-04-23
本文章向大家介绍Hadoop: MapReduce2多个job串行处理，主要内容包括其使用实例、应用技巧、基本知识点总结和需要注意事项，具有一定的参考价值，需要的朋友可以参考一下。

复杂的MapReduce处理中，往往需要将复杂的处理过程，分解成多个简单的Job来执行，第1个Job的输出做为第2个Job的输入，相互之间有一定依赖关系。以上一篇中的求平均数为例，可以分解成三个步骤：

1. 求Sum

2. 求Count

3. 计算平均数

每1个步骤看成一个Job，其中Job3必须等待Job1、Job2完成，并将Job1、Job2的输出结果做为输入，下面的代码演示了如何将这3个Job串起来

  1 package yjmyzz.mr.job.link;
  2 
  3 import org.apache.hadoop.conf.Configuration;
  4 import org.apache.hadoop.fs.Path;
  5 import org.apache.hadoop.io.DoubleWritable;
  6 import org.apache.hadoop.io.LongWritable;
  7 import org.apache.hadoop.io.Text;
  8 import org.apache.hadoop.mapreduce.Job;
  9 import org.apache.hadoop.mapreduce.Mapper;
 10 import org.apache.hadoop.mapreduce.Reducer;
 11 import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
 12 import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
 13 import yjmyzz.util.HDFSUtil;
 14 
 15 import java.io.IOException;
 16 
 17 
 18 public class Avg2 {
 19 
 20     private static final Text TEXT_SUM = new Text("SUM");
 21     private static final Text TEXT_COUNT = new Text("COUNT");
 22     private static final Text TEXT_AVG = new Text("AVG");
 23 
 24     //计算Sum
 25     public static class SumMapper
 26             extends Mapper<LongWritable, Text, Text, LongWritable> {
 27 
 28         public long sum = 0;
 29 
 30         public void map(LongWritable key, Text value, Context context)
 31                 throws IOException, InterruptedException {
 32             sum += Long.parseLong(value.toString());
 33         }
 34 
 35         protected void cleanup(Context context) throws IOException, InterruptedException {
 36             context.write(TEXT_SUM, new LongWritable(sum));
 37         }
 38 
 39     }
 40 
 41     public static class SumReducer extends Reducer<Text, LongWritable, Text, LongWritable> {
 42 
 43         public long sum = 0;
 44 
 45         public void reduce(Text key, Iterable<LongWritable> values, Context context)
 46                 throws IOException, InterruptedException {
 47             for (LongWritable v : values) {
 48                 sum += v.get();
 49             }
 50             context.write(TEXT_SUM, new LongWritable(sum));
 51         }
 52 
 53     }
 54 
 55     //计算Count
 56     public static class CountMapper
 57             extends Mapper<LongWritable, Text, Text, LongWritable> {
 58 
 59         public long count = 0;
 60 
 61         public void map(LongWritable key, Text value, Context context)
 62                 throws IOException, InterruptedException {
 63             count += 1;
 64         }
 65 
 66         protected void cleanup(Context context) throws IOException, InterruptedException {
 67             context.write(TEXT_COUNT, new LongWritable(count));
 68         }
 69 
 70     }
 71 
 72     public static class CountReducer extends Reducer<Text, LongWritable, Text, LongWritable> {
 73 
 74         public long count = 0;
 75 
 76         public void reduce(Text key, Iterable<LongWritable> values, Context context)
 77                 throws IOException, InterruptedException {
 78             for (LongWritable v : values) {
 79                 count += v.get();
 80             }
 81             context.write(TEXT_COUNT, new LongWritable(count));
 82         }
 83 
 84     }
 85 
 86     //计算Avg
 87     public static class AvgMapper
 88             extends Mapper<LongWritable, Text, LongWritable, LongWritable> {
 89 
 90         public long count = 0;
 91         public long sum = 0;
 92 
 93         public void map(LongWritable key, Text value, Context context)
 94                 throws IOException, InterruptedException {
 95             String[] v = value.toString().split("t");
 96             if (v[0].equals("COUNT")) {
 97                 count = Long.parseLong(v[1]);
 98             } else if (v[0].equals("SUM")) {
 99                 sum = Long.parseLong(v[1]);
100             }
101         }
102 
103         protected void cleanup(Context context) throws IOException, InterruptedException {
104             context.write(new LongWritable(sum), new LongWritable(count));
105         }
106 
107     }
108 
109 
110     public static class AvgReducer extends Reducer<LongWritable, LongWritable, Text, DoubleWritable> {
111 
112         public long sum = 0;
113         public long count = 0;
114 
115         public void reduce(LongWritable key, Iterable<LongWritable> values, Context context)
116                 throws IOException, InterruptedException {
117             sum += key.get();
118             for (LongWritable v : values) {
119                 count += v.get();
120             }
121         }
122 
123         protected void cleanup(Context context) throws IOException, InterruptedException {
124             context.write(TEXT_AVG, new DoubleWritable(new Double(sum) / count));
125         }
126 
127     }
128 
129 
130     public static void main(String[] args) throws Exception {
131 
132         Configuration conf = new Configuration();
133 
134         String inputPath = "/input/duplicate.txt";
135         String maxOutputPath = "/output/max/";
136         String countOutputPath = "/output/count/";
137         String avgOutputPath = "/output/avg/";
138 
139         //删除输出目录(可选,省得多次运行时,总是报OUTPUT目录已存在)
140         HDFSUtil.deleteFile(conf, maxOutputPath);
141         HDFSUtil.deleteFile(conf, countOutputPath);
142         HDFSUtil.deleteFile(conf, avgOutputPath);
143 
144         Job job1 = Job.getInstance(conf, "Sum");
145         job1.setJarByClass(Avg2.class);
146         job1.setMapperClass(SumMapper.class);
147         job1.setCombinerClass(SumReducer.class);
148         job1.setReducerClass(SumReducer.class);
149         job1.setOutputKeyClass(Text.class);
150         job1.setOutputValueClass(LongWritable.class);
151         FileInputFormat.addInputPath(job1, new Path(inputPath));
152         FileOutputFormat.setOutputPath(job1, new Path(maxOutputPath));
153 
154 
155         Job job2 = Job.getInstance(conf, "Count");
156         job2.setJarByClass(Avg2.class);
157         job2.setMapperClass(CountMapper.class);
158         job2.setCombinerClass(CountReducer.class);
159         job2.setReducerClass(CountReducer.class);
160         job2.setOutputKeyClass(Text.class);
161         job2.setOutputValueClass(LongWritable.class);
162         FileInputFormat.addInputPath(job2, new Path(inputPath));
163         FileOutputFormat.setOutputPath(job2, new Path(countOutputPath));
164 
165 
166         Job job3 = Job.getInstance(conf, "Average");
167         job3.setJarByClass(Avg2.class);
168         job3.setMapperClass(AvgMapper.class);
169         job3.setReducerClass(AvgReducer.class);
170         job3.setMapOutputKeyClass(LongWritable.class);
171         job3.setMapOutputValueClass(LongWritable.class);
172         job3.setOutputKeyClass(Text.class);
173         job3.setOutputValueClass(DoubleWritable.class);
174 
175         //将job1及job2的输出为做job3的输入
176         FileInputFormat.addInputPath(job3, new Path(maxOutputPath));
177         FileInputFormat.addInputPath(job3, new Path(countOutputPath));
178         FileOutputFormat.setOutputPath(job3, new Path(avgOutputPath));
179 
180         //提交job1及job2,并等待完成
181         if (job1.waitForCompletion(true) && job2.waitForCompletion(true)) {
182             System.exit(job3.waitForCompletion(true) ? 0 : 1);
183         }
184 
185     }
186 
187 
188 }

输入文本在上一篇可以找到，上面这段代码的主要思路：

1. Sum和Count均采用相同的输入/input/duplicate.txt，然后将各自的处理结果分别输出到/output/max/及/output/count/下

2. Avg从/output/max及/output/count获取结果做为输入，然后根据Key值不同，拿到sum和count的值，最终计算并输出到/output/avg/下

随机文章
本站知识点必读
最近更新