MapReduce(五)

MapReduce的（五）

1.MapReduce的多表关联查询。

根据文本数据格式。查询多个文本中的内容关联。查询。

2.MapReduce的多任务窜执行的使用

多任务的串联执行问题，主要是要建立controlledjob，然后建组管理起来。留意多线程因效率而导致执行结束时间不一致的问题。

-------------------------------------------------- -------------------------------------------------- ----------------------------

MapReduce的的的多表关联查询

数据：

ctoryname地址
北京红星1
深圳迅雷3
广州本田2
北京瑞星1
广州发展银行2
腾讯3
北京银行5

addressID地址名称
1北京
2广州
3深圳
4西安

代码：

包com.huhu.day05; 

import java.io.IOException; 

导入org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.util.GenericOptionsParser;
import org.apache.hadoop.util.Tool;
import org.apache.hadoop.util.ToolRunner;

import com.huhu.day04.ProgenyCount; 

/ **
 * *厂名厂址为北京红星1
 *
 *地址addressID地址名称1北京
 *
 *从工厂选择factory.factoryname，address.addressname，地址在哪里
 * factory.addressed = address.addressID
 *
 *流程1.读取这2个文件？1个mapreduce 2.mapper 2个：map--同时可以处理2个文件代码3.map输出kv k：id
 * v：t1：北京红星1 k：id v：t2：1北京4.降低价值{t1：北京红
 *星1，t2：1北京}
 *
 * @作者huhu_k
 *
 * /
公共类扩展ToolRunner implements Tool { 

	私人配置conf; 

	公共静态类MyMapper扩展Mapper <LongWritable，文本，文本，文本> { 

		@覆盖
		protected void map（LongWritable key，Text value，Context context）throws IOException，InterruptedException {
			String [] line = value.toString（）。split（“\ t”）;
			如果（line [0] .matches（“\\ d”））{
				// k：1 v：t1：1：北京
				context.write（new Text（line [0]），new Text（“t1”+ line [0] +“：”+ line [1]））;
			} else {
				// k：1 v：t2：beijingredstar：1
				context.write（new Text（line [1]），new Text（“t2”+ line [0] +“：”+ line [1]）） ;
			}
		}
	} 

	公共静态类MyReduce扩展减速器{ 

		@覆盖
		保护无效设置（上下文上下文）抛出IOException，InterruptedException {
			context.write（new Text（“factoryname \ t \ t”），新文本（“地址名称”））;
		} 

		@覆盖
		protected void reduce（Text key，Iterable <Text> values，Context context）
				抛出IOException，InterruptedException {
			String fsc =“”;
			String addr =“”;
			for（Text s：values）{
				String line = s.toString（）;
				if（line.contains（“t1”））{
					addr = line.split（“：”）[1];
				} else if（line.contains（“t2”））{
					fsc = line.split（“：”）[0];
				}
			} 

			if（！fsc.equals（“”）&&！addr.equals（“”））{
				context.write（new Text（fsc），new Text（addr））;
			}
		} 

		@覆盖
		保护无效清理（上下文上下文）抛出IOException，InterruptedException {
		}
	} 

	公共静态无效的主要（字符串[]参数）抛出异常{
		多重连接t = new MutipleJoin（）;
		配置conf = t.getConf （）;
		String [] other = new GenericOptionsParser（conf，args）.getRemainingArgs（）;
		if（other.length！= 2）{
			System.err.println（“number is fail”）;
		}
		int run = ToolRunner.run（conf，t，args）;
		System.exit（运行）;
	} 

	@覆盖
	public Configuration getConf（）{
		if（conf！= null）{
			返回conf;
		}
		返回新的配置（）;
	} 

	@覆盖
	public void setConf（Configuration arg0）{ 

	} 

	@覆盖
	公共诠释运行（字符串[]其他）抛出异常{
		配置con = getConf（）;
		Job job = Job.getInstance（con）;
		job.setJarByClass（ProgenyCount.class）;
		job.setMapperClass（MyMapper.class）;
		job.setMapOutputKeyClass（Text.class）;
		job.setMapOutputValueClass（Text.class）; 

		//默认分区
		// job.setPartitionerClass（HashPartitioner.class）; 

		job.setReducerClass（MyReduce.class）;
		job.setOutputKeyClass（Text.class）;
		job.setOutputValueClass（Text.class）; 

		FileInputFormat.addInputPath（job，new Path（“hdfs：// ry-hadoop1：8020 / in / day05”））;
		Path path = new Path（“hdfs：// ry-hadoop1：8020 / out / day05.txt”）;
		FileSystem fs = FileSystem.get（getConf（））;
		if（fs.exists（path））{
			fs.delete（path，true）;
		}
		FileOutputFormat.setOutputPath（job，path）; 

		返回job.waitForCompletion（true）？0：1;
	} 

}

运行结果：

将有规律的数据进行关联查询。

二。MapReduce的的多任务窜改的使用

WordCount_Mapper

包com.huhu.day05; 

import java.io.IOException; 

import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
导入org.apache.hadoop.mapreduce.Mapper; 

公共类WordCount_Mapper扩展映射器<LongWritable，Text，Text，IntWritable> { 

	private final IntWritable one = new IntWritable（1）; 

	@覆盖
	保护无效映射（LongWritable键，文本值，映射器<LongWritable，文本，文本，IntWritable> .Context上下文）
			抛出IOException，InterruptedException {
		String [] line = value.toString（）。split（“”）;
		for（String s：line）{
			context.write（new Text（s），one）;
		}
	}
}

WordCount_Reduce

包com.huhu.day05; 

import java.io.IOException; 

import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer; 

公共类WordCount_Reducer扩展Reducer <Text，IntWritable，Text，IntWritable> { 

	@覆盖
	protected void reduce（Text key，Iterable <IntWritable> values，Context context）
			抛出IOException，InterruptedException { 

		int sum = 0; 

		for（IntWritable i：values）{
			sum + = i.get（）;
		}
		context.write（key，new IntWritable（sum））;
	}
}

Top10_Mapper

包com.huhu.day05; 

import java.io.IOException; 

import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
导入org.apache.hadoop.mapreduce.Mapper; 

公共类Top10_Mapper扩展了Mapper <LongWritable，Text，Text，IntWritable> { 

	@覆盖
	protected void map（LongWritable key，Text value，Context context）throws IOException，InterruptedException {
		String [] line = value.toString（）。split（“\ t”）;
		context.write（new Text（line [0]），new IntWritable（Integer.parseInt（line [1]）））;
	}
}

Top10_Reducer

包com.huhu.day05; 

import java.io.IOException;
import java.util.TreeSet; 

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 com.huhu.day05.pojo.WordCount; 

公共类Top10_Reducer扩展Reducer <Text，IntWritable，WordCount，NullWritable> { 

	private TreeSet <WordCount> set = new TreeSet <>（）; 

	@覆盖
	protected void reduce（Text key，Iterable <IntWritable> values，Context context）
			抛出IOException，InterruptedException { 

		for（IntWritable v：values）{
			System.err.println（v.toString（）+“----- -----------”）;
			set.add（new WordCount（key.toString（），Integer.parseInt（v.toString（））））;
		} 

		if（10 <set.size（））{
			set.remove（set.last（））;
		} 

	} 

	@覆盖
	保护无效清理（上下文上下文）抛出IOException，InterruptedException {
		for（WordCount w：set）{
			context.write（w，NullWritable.get（））;
		}
	}
}

WordCountTop_Cuan

包com.huhu.day05; 

导入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.mapred.jobcontrol.JobControl;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.jobcontrol.ControlledJob;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.util.GenericOptionsParser;
import org.apache.hadoop.util.Tool;
import org.apache.hadoop.util.ToolRunner;

import com.huhu.day05.pojo.WordCount; 

公共类WordCountTop_Cuan扩展ToolRunner实现工具{ 

	私人配置con; 

	@覆盖
	public配置getConf（）{
		如果（con！= null）
			返回con;
		返回新的配置（）;
	} 

	@覆盖
	public void setConf（Configuration arg0）{
	} 

	@覆盖
	公共诠释运行（字符串[] arg0）抛出异常{
		配置con = getConf（）;}
		Job WordJob = Job.getInstance（con，“WordCount Job”）;
		WordJob.setJarByClass（WordCountTop_Cuan.class）;
		WordJob.setMapperClass（WordCount_Mapper.class）;
		WordJob.setMapOutputKeyClass（Text.class）;
		WordJob.setMapOutputValueClass（IntWritable.class）; 

		WordJob.setReducerClass（WordCount_Reducer.class）;
		WordJob.setOutputKeyClass（WordCount.class）;
		WordJob.setOutputValueClass（NullWritable.class）; 

		FileInputFormat.addInputPath（WordJob，new Path（“hdfs：// ry-hadoop1：8020 / in / ihaveadream.txt”））;
		Path path = new Path（“hdfs：// ry-hadoop1：8020 / out / Word_job.txt”）;
		FileSystem fs = FileSystem.get（getConf（））;
		if（fs.exists（path））{
			fs.delete（path，true）;
		}
		FileOutputFormat.setOutputPath（WordJob，path）; 

		Job TopJob = Job.getInstance（con，“Top10 Job”）;
		TopJob.setJarByClass（WordCountTop_Cuan.class）;
		TopJob.setMapperClass（Top10_Mapper.class）;
		TopJob.setMapOutputKeyClass（Text.class）;
		TopJob.setMapOutputValueClass（IntWritable.class）;

		TopJob.setReducerClass（Top10_Reducer.class）;
		TopJob.setOutputKeyClass（WordCount.class）;
		TopJob.setOutputValueClass（NullWritable.class）; 

		FileInputFormat.addInputPath（TOPJOB，路径）;
		Path paths = new Path（“hdfs：// ry-hadoop1：8020 / out / Top_Job.txt”）;
		if（fs.exists（paths））{
			fs.delete（paths，true）;
		}
		FileOutputFormat.setOutputPath（TopJob，paths）; 

		//重点
		ControlledJob controlledWC = new ControlledJob（WordJob.getConfiguration（））;
		ControlledJob controlledTP = new ControlledJob（TopJob.getConfiguration（））; 

		// JobTop依赖JobWC
		controlledTP.addDependingJob（controlledWC）;
		//定义控制器
		JobControl jobControl =新的JobControl（“WordCount和Top”）;
		jobControl.addJob（controlledWC）;
		jobControl.addJob（controlledTP）; 

		线程线程=新线程（JobControl作业控制）;
		thread.start（）; 

		而{（jobControl.allFinished（）！）
			了了Thread.sleep（1000）;
		} 

		jobControl.stop（）; 

		返回0;
	} 

	公共静态无效的主要（字符串[]参数）抛出异常{ 

		WordCountTop_Cuan wc = new WordCountTop_Cuan（）;
		配置conf = wc.getConf（）;
		String [] other = new GenericOptionsParser（conf，args）.getRemainingArgs（）;
		int run = ToolRunner.run（conf，wc，other）;
		System.exit（运行）;
	}
}

运行结果：

我是在本地运行的，如果在Hadoop的的上运行输入命令

hadoop jar xxx.jar /in/xx.txt /out/Word_Job.txt /out/Top_Job.txt

此时Top_Job依赖于Word_Job

因为Top_Job的输入路径是Word_Job的输出路径。当线程只启动一个工作，Top_job等待Word_Job运行完，Top_Job开始运行。