MapReduce 组合模式(ControlledJob)，链式模式(ChainMapper,ChainReducer)，迭代模式

最新推荐文章于 2023-05-09 20:39:51 发布
最新推荐文章于 2023-05-09 20:39:51 发布
阅读量1.1k 收藏 2
点赞数
CC 4.0 BY-SA版权
分类专栏： Hadoop-MR 文章标签： Hadoop MapReduce 组合模 迭代模式 链式模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/u011317245/article/details/53445662
本文介绍MapReduce的不同应用场景，包括迭代式处理、依赖组合处理及链式处理的方法与实现。通过具体示例展示了如何配置和执行这些复杂任务。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

MrType2测试数据：

张三:11
张三:12
李四:10
王五:10
李四:11
王五:11


MrType3测试数据： 

shoe	121
t-shirt	20
basketball	1200



package com.learn.mr;

import java.io.IOException;
import java.net.URI;

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.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.io.WritableComparator;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.chain.ChainMapper;
import org.apache.hadoop.mapreduce.lib.chain.ChainReducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.input.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.jobcontrol.ControlledJob;
import org.apache.hadoop.mapreduce.lib.jobcontrol.JobControl;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;
import org.apache.hadoop.mapreduce.lib.partition.HashPartitioner;
import org.apache.hadoop.util.Tool;
import org.apache.hadoop.util.ToolRunner;


/**
 * 组合 迭代 链式
 * 
 */
public class MrType extends Configuration implements Tool {
	/**
	 * 1.迭代式MapReduce
	 * 一些复杂的任务难以用一次mapreduce处理完成,需要多次mapreduce才能完成任务,例如PageRank,Kmeans算法都需要多次的迭代
	 * ,关于mapreduce迭代
	 * 在mahout中运用较多.在mapreduce迭代过程中,思想还是比较简单,就像类似for循环一样,前一个mapreduce的输出结果,
	 * 作为下一个mapreduce的输入,任务完成后中间结果都可以删除
	 * 
	 * MapReduce迭代的问题 每次迭代都需要重新初始化Job,重新申请资源 每次迭代,之间的数据交互都需要写入I/O
	 * 
	 * 对于以上两点,常用的阶段办法就是 Tez
	 */
	public static void main(String[] args) {
		try {
			//ToolRunner.run(new MrType(), args);
			ToolRunner.run(new MrType2(), args);
			//ToolRunner.run(new MrType3(), args);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	@Override
	public void setConf(Configuration conf) {
	}

	@Override
	public Configuration getConf() {
		return null;
	}

	static class MyMapper extends Mapper<LongWritable, Text, LongWritable, Text> {
		@Override
		protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
			value.set(value.toString() + 1);
			context.write(key, value);
		}
	}

	static class MyReducer extends Reducer<LongWritable, Text, LongWritable, Text> {
		@Override
		protected void reduce(LongWritable key, Iterable<Text> value, Context context)
				throws IOException, InterruptedException {
			Text t = new Text();
			for (Text t1 : value) {
				t.set(t.toString() + t1.toString());
			}
			context.write(key, t);
		}
	}

	@Override
	public int run(String[] args) throws Exception {
		Configuration conf = new Configuration();
		FileSystem fs = FileSystem.get(new URI(args[0]), conf);
		Path path = new Path(args[1]);
		if (fs.exists(path)) {
			fs.delete(path, true);
		}

		Job job = new Job(conf, MrType.class.getSimpleName());
		FileInputFormat.setInputPaths(job, args[0]);
		job.setInputFormatClass(TextInputFormat.class);

		job.setMapperClass(MyMapper.class);
		job.setMapOutputKeyClass(LongWritable.class);
		job.setMapOutputValueClass(Text.class);

		job.setPartitionerClass(HashPartitioner.class);
		job.setNumReduceTasks(1);

		// job.setCombinerClass(null);

		job.setReducerClass(MyReducer.class);
		job.setOutputKeyClass(LongWritable.class);
		job.setOutputValueClass(Text.class);

		FileOutputFormat.setOutputPath(job, path);
		job.setOutputFormatClass(TextOutputFormat.class);

		job.waitForCompletion(true);

		Job job2 = new Job(conf, MrType.class.getSimpleName());
		FileInputFormat.setInputPaths(job2, args[1]);
		job2.setInputFormatClass(TextInputFormat.class);

		job2.setMapperClass(MyMapper.class);
		job2.setMapOutputKeyClass(LongWritable.class);
		job2.setMapOutputValueClass(Text.class);

		job2.setPartitionerClass(HashPartitioner.class);
		job2.setNumReduceTasks(1);

		job2.setReducerClass(MyReducer.class);
		job2.setOutputKeyClass(LongWritable.class);
		job2.setOutputValueClass(Text.class);

		if (fs.exists(new Path(args[2]))) {
			fs.delete(new Path(args[2]), true);
		}
		FileOutputFormat.setOutputPath(job2, new Path(args[2]));
		job2.setOutputFormatClass(TextOutputFormat.class);

		job2.waitForCompletion(true);

		return 0;
	}
}


/**
 * 依赖组合
 */
class MrType2 extends Configuration implements Tool {

	static class SumMapper extends Mapper<LongWritable, Text, Text, IntWritable> {
		Text k1 = new Text();
		IntWritable v1 = new IntWritable();

		@Override
		protected void setup(Context context) throws IOException, InterruptedException {

		}

		@Override
		protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
			String[] arrays = value.toString().split(":");
			k1.set(arrays[0]);
			v1.set(Integer.parseInt(arrays[1]));
			context.write(k1, v1);
		}
	}

	static class SumReducer extends Reducer<Text, IntWritable, Text, IntWritable> {
		IntWritable v1 = new IntWritable();

		@Override
		protected void reduce(Text key, Iterable<IntWritable> value, Context context)
				throws IOException, InterruptedException {
			int sum = 0;
			for (IntWritable i : value) {
				sum += i.get();
			}
			v1.set(sum);
			context.write(key, v1);
		}
	}

	static class SortMapper extends Mapper<LongWritable, Text, IntWritable, Text> {
		IntWritable k1 = new IntWritable();
		Text v1 = new Text();

		@Override
		protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
			String arrays[] = value.toString().split("	");
			k1.set(Integer.parseInt(arrays[1]));
			v1.set(arrays[0]);
			context.write(k1, v1);
		}
	}

	static class SortReducer extends Reducer<IntWritable, Text, Text, IntWritable> {
		@Override
		protected void reduce(IntWritable key, Iterable<Text> value, Context context)
				throws IOException, InterruptedException {
			for (Text t : value) {
				context.write(t, key);
			}
		}
	}

	static class SortClass extends WritableComparator {
		public SortClass() {
			super(IntWritable.class, true);// 注册排序组件
		}

		@Override
		public int compare(byte[] b1, int s1, int l1, byte[] b2, int s2, int l2) {
			System.out.println("==b1=="+b1);
			System.out.println("==s1=="+s1);
			System.out.println("==l1=="+l1);
			System.out.println("==b2=="+b2);
			System.out.println("==s2=="+s2);
			System.out.println("==l2=="+l2);
			
			return -super.compare(b1, s1, l1, b2, s2, l2);
		}

		@Override
		public int compare(Object a, Object b) {
			System.out.println("=========================");
			System.out.println(a);
			System.out.println("------------------------");
			System.out.println(b);
			return -super.compare(a, b);
		}
	}

	@Override
	public void setConf(Configuration conf) {
	}

	@Override
	public Configuration getConf() {
		return null;
	}

	/**
	 * 依赖关系组合式:
	 */
	@SuppressWarnings("deprecation")
	@Override
	public int run(String[] args) throws Exception {
		Job job = new Job(new Configuration(), "job1");
		job.setMapperClass(SumMapper.class);
		job.setReducerClass(SumReducer.class);
		FileInputFormat.setInputPaths(job, args[0]);
		FileSystem fs = FileSystem.get(new URI(args[0]), job.getConfiguration());
		Path path = new Path(args[1]);
		if (fs.exists(path)) {
			fs.delete(path, true);
		}
		FileOutputFormat.setOutputPath(job, path);
		job.setInputFormatClass(TextInputFormat.class);
		job.setMapOutputKeyClass(Text.class);
		job.setMapOutputValueClass(IntWritable.class);
		job.setOutputKeyClass(Text.class);
		job.setOutputValueClass(IntWritable.class);

		Job job2 = new Job(new Configuration(), "job2");
		job2.setInputFormatClass(TextInputFormat.class);
		job2.setMapperClass(SortMapper.class);
		job2.setReducerClass(SortReducer.class);
		job2.setSortComparatorClass(SortClass.class);
		FileInputFormat.setInputPaths(job2, args[1]);
		Path path2 = new Path(args[2]);
		if (fs.exists(path2)) {
			fs.delete(path2, true);
		}
		FileOutputFormat.setOutputPath(job2, path2);
		job2.setMapOutputKeyClass(IntWritable.class);
		job2.setMapOutputValueClass(Text.class);
		job2.setOutputKeyClass(Text.class);
		job2.setOutputValueClass(IntWritable.class);

		ControlledJob controll = new ControlledJob(job.getConfiguration());
		controll.setJob(job);

		ControlledJob controll2 = new ControlledJob(job2.getConfiguration());
		controll2.setJob(job2);

		controll2.addDependingJob(controll);

		JobControl jc = new JobControl("jc-test");
		jc.addJob(controll);
		jc.addJob(controll2);

		/** 由于JobControl实现了Runnable接口,而Runnable接口只有运行方法,没有结束方法,因此需要一个线程来辅助 */
		/** 如果不通过Thread运行,就会导致Hadoop中所有Job执行完毕之后,最后不会退出 */
		Thread jcThread = new Thread(jc);
		jcThread.start();
		while (true) {
			// 当job池里所有的Job完成后,执行 下一步操作
			if (jc.allFinished()) {
				System.out.println(jc.getSuccessfulJobList());
				jc.stop();
				return 0;
			}
			if (jc.getFailedJobList().size() > 0) {
				System.out.println(jc.getFailedJobList());
				jc.stop();
				return 1;
			}
		}
	}
}

/**
 * 链式MapReduce
 * 链式MapReduce的执行规则:整改Job中只能有一个Reducer,在Reducer前面可以有一个或者多个Mapper,在Reducer的后面可以有0个或者多个Mapper
 */
class MrType3 extends Configuration implements Tool{
	
	static class FirstMapper extends Mapper<LongWritable,Text,Text,IntWritable>{
		@Override
		protected void map(LongWritable key, Text value,Context context)
				throws IOException, InterruptedException {
			String arrays[]=value.toString().split("	");
			int num=Integer.parseInt(arrays[1]);
			if(num<10000){
				context.write(new Text(arrays[0]),new IntWritable(Integer.parseInt(arrays[1])));
			}
		}
	}
	static class SecondMapper extends Mapper<Text,IntWritable,Text,IntWritable>{
		@Override
		protected void map(Text key, IntWritable value,Context context)
				throws IOException, InterruptedException {
			if(value.get()<=100){
				context.write(key, value);
			}
		}
	}
	static class FirstReduce extends Reducer<Text,IntWritable,Text,IntWritable>{
		@Override
		protected void reduce(Text key, Iterable<IntWritable> value,Context context) throws IOException, InterruptedException {
			int sum=0;
			for(IntWritable i:value){
				sum+=i.get();
			}
			context.write(key,new IntWritable(sum));
		}
	}
	static class ThirdMapper extends Mapper<Text,IntWritable,Text,IntWritable>{
		@Override
		protected void map(Text key, IntWritable value,Context context)
				throws IOException, InterruptedException {
			if(key.toString().length()<=8){
				context.write(key, value);
			}
		}
	}
	
	@Override
	public void setConf(Configuration conf) {
	}

	@Override
	public Configuration getConf() {
		return null;
	}

	@Override
	public int run(String[] args) throws Exception {
		Configuration conf=new Configuration();
		FileSystem fs=FileSystem.get(new URI(args[0]),conf);
		Path path=new Path(args[1]);
		if(fs.exists(path)){
			fs.delete(path,true);
		}
		Job job=new Job(conf,MrType3.class.getSimpleName());
		FileInputFormat.setInputPaths(job,args[0]);
		job.setInputFormatClass(TextInputFormat.class);
		
		ChainMapper.addMapper(job,FirstMapper.class,LongWritable.class,Text.class,Text.class,IntWritable.class,conf);
		ChainMapper.addMapper(job,SecondMapper.class,Text.class,IntWritable.class,Text.class,IntWritable.class,conf);
		ChainReducer.setReducer(job,FirstReduce.class,Text.class,IntWritable.class,Text.class,IntWritable.class,conf);
		ChainMapper.addMapper(job,ThirdMapper.class,Text.class,IntWritable.class,Text.class,IntWritable.class,conf);
		
		job.setMapOutputKeyClass(Text.class);
		job.setMapOutputValueClass(IntWritable.class);
		job.setOutputKeyClass(Text.class);
		job.setOutputValueClass(IntWritable.class);
		
		job.setPartitionerClass(HashPartitioner.class);
		job.setNumReduceTasks(1);
		
		FileOutputFormat.setOutputPath(job,path);
		job.setOutputFormatClass(TextOutputFormat.class);
		
		return job.waitForCompletion(true)?0:1;
	}
}


MapReduce---chain链条式操作
tianqinglei的博客
08-18 919
准备数据： hello world of tom1 hello world of tom1 hello world of tom2 hello world of tom3 hello world of tom3 hello world of tom4 hello world of tom4 思路分析图： 1、Mapper1(切割单词) 2、Mapper2 （滤掉单词中o
链式MapReduce：ChainMapper和ChainReducer
lavimer
04-10 3171
一：背景 Hadoop2.0开始MapReduce作业支持链式处理，类似于富士康生产苹果手机的流水线，每一个阶段都有特定的任务要处理，比如提供原配件——>组装——打印出厂日期，等等。通过这样进一步的分工，从而提高了生成效率，我们Hadoop中的链式MapReduce也是如此，这些Mapper可以像水流一样，一级一级向后处理，有点类似于Linux的管道。前一个Mapper的输出结果直接可以作为下一
多个mapreduce过程的组合模式
404
05-05 1059
1、作业链 mapreduce作业可以一次创建并依次执行。
复合式MapReduce之ChainJob
weixin_30756499的博客
10-13 91
依赖式的场景 我们可以设想一下MapReduce有2个子任务job1，job2构成，job2要在job1完成之后才执行。 job1：用上篇写的合并小文件 job2：使用单词计数 这种关系就叫复杂数据依赖关系的组合时mapreduce。 hadoop为这种组合关系提供了一种执行和控制机制，hadoop通过job和jobControl类提供具体的编程方法。 ...
Mapreduce和Yarn概念，参数优化，作用，原理，MapReduce计数器 Counter,MapReduce 多job串联之ControlledJob(来自学习资料)...
weixin_33697898的博客
06-04 192
3.3. MapReduce与YARN 3.3.1 YARN概述 Yarn是一个资源调度平台，负责为运算程序提供服务器运算资源，相当于一个分布式的操作系统平台，而mapreduce等运算程序则相当于运行于操作系统之上的应用程序 3.3.2 YARN的重要概念 1、 yarn并不清楚用户提交的程序的运行机制 2、 yarn只提供运算资源的调度（用...
mapreduce的迭代 组合 链式
xuefengmiao的专栏
05-03 762
能够到这一步，说明已经对hadoop入门，并且产生问题。这个问题，似乎困惑了不少初学者。 1.比如我们输出的mapreduce结果，需要进入下一个mapreduce，该怎么解决？ 可以使用迭代式 2.那么什么是迭代式? 3.什么是依赖式？ 4.什么是链式？ 5.三种模式各自的应用场景是什么？ 网上不少资料，但是对于新手，很难辨认，这里给大家指出这里面的关键点：
MapReduce 设计模式
03-19
MapReduce设计模式是对MapReduce编程范式的进一步深化，通过多种不同的算法和策略来解决数据处理中的常见问题。 本文档中提到了《MapReduce设计模式》这本书，由Donald Miner和Adam Shook所著。书籍的标题说明了其...
MapReduce设计模式
03-03
, 由于本书不会过多涉及底层框架及MapReduce API，所以希望读者阅读《MapReduce设计模式》之前，能够对Hadoop系统有所了解，知道如何编写MapReduce程序，并了解MapReduce程序框架的工作原理。《MapReduce设计模式》...
mapreduce 设计模式
08-16
书中主要介绍编程模式，即如何利用MapReduce框架解决一类问题，重在提供解决问题的方法和思路。作者花大量篇幅介绍各种模式的原理及实现机制，并给出相应的应用实例，让读者对每种模式能有更直观的理解。
jobcontrol
小魏的博客
06-20 843
jobcontrol可以实现多个job结合起来运行。下面就是有两个job的jobcontrol，第一个job的输出是第二个job的输入。 package hadoop; import java.io.IOException; import java.util.StringTokenizer; import org.apache.hadoop.conf.Configuration; import
使用JobControl管理mapreduce多job依赖
lvhuiyin的博客
05-08 761
当MapReduce中作业不止一个，如果管理这些作业按照顺序执行，主要考虑是否有个线性的作业链或有向无环图（DAG） 对于线性链表最简单的就是一个接一个的运行作业，对于比线性链表更复杂的结构，有相关的类库可以帮助你合理安排工作流，最简单的就是org.apache.hadoop.mapred.jobcontrol包中的JobControl类，JobControl实例代表一个作业的运行图，可以加入作
任务管理（job control）
一个搬运知识的笨小孩
03-11 778
目录1. 任务管理1.1 job control 的管理1.1.0 使用 & 直接将命令丢到后台中运行1.1.1 将目前的任务丢到后台中暂停：[Ctrl]+z1.1.2 查看目前的后台任务状态：jobs1.1.3 将后台任务拿到前台来处理：fg1.1.4 让任务在后台下的状态变成运行中：bg1.1.5 管理后台当中的任务：kill1.2 脱机管理问题 1. 任务管理 任务管理是用在 bash 环境中的，也就是说【当我们登录系统获取 bash shell 后，再单一终端下同时执行多个任务的操作管理】
基本MapReduce模式
小飞侠的博客
02-16 144
计数与求和 问题陈述: 　　有许多文档，每个文档都有一些字段组成。需要计算出每个字段在所有文档中的出现次数或者这些字段的其他什么统计值。例如，给定一个log文件，其中的每条记录都包含一个响应时间，需要计算出平均响应时间。 解决方案: 　　让我们先从简单的例子入手。在下面的代码片段里，Mapper每遇到指定词就把频次记1，Reducer一个个遍历这些词的集...
Hadoop 里MapReduce里 实现多个job任务 包含（迭代式、依赖式、链式）
精益求精
11-03 837
一、迭代式，所谓的迭代式，下一个执行的Job任务以上一个Job的输出作为输入，最终得到想要的结果。 这里我只写关键的代码了 [java] view plain copy Job job = new Job(new Configuration(),“test”);    JobConf jobConf=(JobConf) job.getConfiguration();  jobConf
MapReduce 顺序组合， 迭代式，组合式，链式
hwm957809750的专栏
07-09 223
1、顺序组合式 顺序组合式就是按照指定顺序执行任务如：mapreduce1 --&gt; mapreduce2 --&gt; mapreduce3 即：mapreduce1的输出是mapreduce2的输入，mapreduce2的输出式mapreduce3的输入 代码片段如下： String inPath1 = "hdfs://hadoop0:9000/user/root/3D/"; ...
Hadoop-MapReduce的多job串联
互联网知识分享
05-09 348
（2）创建一个管理组control，用于管理创建的controlledJob对象,自定义组名。设置路径,第二个的MapReduce的输入路径就是前面的MapReduce的输出路径。因此我们让当前线程（main线程）在发现job线程没结束的情况下，稍微等他0.5秒钟。某些原行数据的a.txt文件的内容格式 index Inverted index。某些原行数据的c.txt文件的内容格式 index Inverted index。往往会出现job线程还在执行，而main线程已经结束,所以需要手动关闭。
MapReduce之多job串联
Running_Tiger的博客
02-09 473
MapReduce之多job串联 一个稍复杂点的处理逻辑往往需要多个 mapreduce 程序串联处理，多 job 的串联可以借助 mapreduce 框架的 JobControl 实现 示例代码： ControlledJob controlledJob1 = new ControlledJob(job1.getConfiguration()); controlledJo...
Hadoop的JobControl设计及用法
yancychas的博客
06-05 1638
JobControl设计及用法1、JobControl设计原理分析：JobControl由两个类组成：Job和JobControl。Job类封装了一个MapReduce作业及其对应的依赖关系，主要负责监控各个依赖作业的运行状态，一次更新自己的状态。作业刚开始处于WAITING状态。如果没有依赖作业或者所有作业均已运行完成，则进入READY状态。一旦进入REDAY状态，则作业可被提交到Hadoop集...
最简单的理解组合模式
xie__jin__cheng的博客
02-19 446
价值：把简单对象（leaf）和组合对象（Composite）都当成一种对象使用，对于使用者不需要关心他使用的对象是个简单对象还是复杂对象，就一样：你用就是了，就用一种方式（Operation）取用，至于对象本身的差别有我来完成（多态）. 就这一句话，如果你不能理解，那么也请被浪费时间，找更合适的资料去看。（建议加强一下对面向对象知识的深刻理解） ...
MapReduce编程模式解析
"MapReduce 设计模式" MapReduce是一种分布式计算框架，由Google在2004年提出，主要用于处理和生成大数据集。该框架借鉴了函数式编程的概念，将复杂的大规模数据处理任务分解为两个主要阶段：Map（映射）和Reduce...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值