Hadoop（四）之MapReduce入门

最新推荐文章于 2023-05-23 09:58:46 发布

一棵树～

最新推荐文章于 2023-05-23 09:58:46 发布

阅读量194

点赞数

分类专栏：【大数据-Hadoop】文章标签： Hadoop MapReduce

本文链接：https://blog.csdn.net/MyronCham/article/details/84564459

版权

【大数据-Hadoop】专栏收录该内容

9 篇文章 0 订阅

订阅专栏

4.3、定义一个主类，用来描述job并提交job

5、MapReduce程序提交运行模式及debug方法

5.1、本地运行模式

5.2、集群运行模式

6、MapReduce中的Combiner

7、MapReduce中的序列化

8、MapReduce的排序初步

Mapreduce是一个分布式的运算编程框架，核心功能是将用户编写的核心逻辑代码分布式地运行在一个集群的很多服务器上。

1、为什么要MapReduce

（1）海量数据在单机上处理因为硬件资源限制，无法胜任，因为需要采用分布式集群的方式来处理。
（2）而一旦将单机版程序扩展到集群来分布式运行，将极大地增加程序的复杂度和开发难度。
（3）引入mapreduce框架后，开发人员可以将绝大部分工作集中在业务逻辑的开发上，而将分布式计算中的复杂性交由框架来处理。

2、MapReduce程序运行演示

Hadoop的发布包中内置了一个hadoop-mapreduce-example-2.4.1.jar，这个jar包中有各种MR示例程序，可以通过以下步骤运行：

启动hdfs，yarn

然后在集群中的任意一台服务器上执行，（比如运行wordcount）：

hadoop jar hadoop-mapreduce-example-2.4.1.jar wordcount /wordcount/data /wordcount/out

3、MapReduce 编程规范

用户程序会分成三个部分：Mapper，Reducer，Driver
Mapper的输入数据是KV对的形式，KV的类型可以设置
Mapper的输出数据是KV对的形式，KV的类型可以设置
Mapper中的业务逻辑写在map方法中
map方法是每进来一个KV对调用一次
Reducer的输入数据应该对应Mapper的输出数据，也是KV
Reducer的业务逻辑写在reduce方法中
reduce方法是对每一个<key,valueList>调用一次
用户的Mapper和Reducer都要继承各自的父类
整个程序需要一个Drvier来进行提交，提交的是一个描述了各种必要信息的job对象

4、wordcount示例编写

4.1、定义一个mapper类

//首先要定义四个泛型的类型
//keyin:  LongWritable    valuein: Text
//keyout: Text            valueout:IntWritable

public class WordCountMapper extends Mapper<LongWritable, Text, Text, IntWritable>{
	//map方法的生命周期：  框架每传一行数据就被调用一次
	//key :  这一行的起始点在文件中的偏移量
	//value: 这一行的内容
	@Override
	protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
		//拿到一行数据转换为string
		String line = value.toString();
		//将这一行切分出各个单词
		String[] words = line.split(" ");
		//遍历数组，输出<单词，1>
		for(String word:words){
			context.write(new Text(word), new IntWritable(1));
		}
	}
}

4.2、定义一个reducer类

	//生命周期：框架每传递进来一个kv 组，reduce方法被调用一次
	@Override
	protected void reduce(Text key, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException {

		//定义一个计数器
		int count = 0;
		//遍历这一组kv的所有v，累加到count中
		for(IntWritable value:values){
			count += value.get();
		}
		context.write(key, new IntWritable(count));
	}
}

4.3、定义一个主类，用来描述job并提交job

public class WordCountRunner {
	//把业务逻辑相关的信息（哪个是mapper，哪个是reducer，要处理的数据在哪里，输出的结果放哪里。。。。。。）描述成一个job对象
	//把这个描述好的job提交给集群去运行
	public static void main(String[] args) throws Exception {
		Configuration conf = new Configuration();
		Job wcjob = Job.getInstance(conf);
		//指定我这个job所在的jar包
//		wcjob.setJar("/home/hadoop/wordcount.jar");
		wcjob.setJarByClass(WordCountRunner.class);
		
		wcjob.setMapperClass(WordCountMapper.class);
		wcjob.setReducerClass(WordCountReducer.class);
		//设置我们的业务逻辑Mapper类的输出key和value的数据类型
		wcjob.setMapOutputKeyClass(Text.class);
		wcjob.setMapOutputValueClass(IntWritable.class);
		//设置我们的业务逻辑Reducer类的输出key和value的数据类型
		wcjob.setOutputKeyClass(Text.class);
		wcjob.setOutputValueClass(IntWritable.class);
		
		//指定要处理的数据所在的位置
		FileInputFormat.setInputPaths(wcjob, "hdfs://hdp-server01:9000/wordcount/data/big.txt");
		//指定处理完成之后的结果所保存的位置
		FileOutputFormat.setOutputPath(wcjob, new Path("hdfs://hdp-server01:9000/wordcount/output/"));
		
		//向yarn集群提交这个job
		boolean res = wcjob.waitForCompletion(true);
		System.exit(res?0:1);
	}
}

5、MapReduce程序提交运行模式及debug方法

5.1、本地运行模式

mapreduce程序是被提交给LocalJobRunner在本地运行
而处理的数据及输出结果可以在本地文件系统，也可以在hdfs上
怎样实现本地运行？：写一个程序，不要带集群的配置文件（本质是你的mr程序的conf中是否有mapreduce.framework.name=local以及yarn.resourcemanager.hostname参数）

5.2、集群运行模式

mapreduce程序会提交给yarn集群的resourcemanager，分发到很多的节点上并发执行
处理的数据和输出结果应该位于hdfs文件系统
怎样实现集群运行：

A、将程序打成JAR包，然后在集群的任意一个节点上用hadoop命令启动

$ hadoop jar wordcount.jar com.example.bigdata.mrsimple.WordCountDriver inputpath outputpath

B、直接在linux的eclipse中运行main方法

（项目中要带参数：mapreduce.framework.name=yarn以及yarn的两个基本配置）

C、如果要在windows的eclipse中提交job给集群，则要修改YarnRunner类

6、MapReduce中的Combiner

combiner是MR程序中Mapper和Reducer之外的一种组件
combiner组件的父类就是Reducer
Combiner和reducer的区别在于运行的位置：

Combiner是在每一个maptask所在的节点运行

Reducer是接收全局所有Mapper的输出结果；

7、MapReduce中的序列化

1.Java的序列化是一个重量级序列化框架（Serializable），一个对象被序列化后，会附带很多额外的信息（各种校验信息，header，继承体系。。。。），所以很臃肿，不便于在网络中高效传输；

所以，hadoop自己开发了一套序列化机制（Writable），精简，高效

2.简单代码验证两种序列化机制的差别：

public class TestSeri {
	public static void main(String[] args) throws Exception {
		//定义两个ByteArrayOutputStream，用来接收不同序列化机制的序列化结果
		ByteArrayOutputStream ba = new ByteArrayOutputStream();
		ByteArrayOutputStream ba2 = new ByteArrayOutputStream();

		//定义两个DataOutputStream，用于将普通对象进行jdk标准序列化
		DataOutputStream dout = new DataOutputStream(ba);
		DataOutputStream dout2 = new DataOutputStream(ba2);
		ObjectOutputStream obout = new ObjectOutputStream(dout2);
		//定义两个bean，作为序列化的源对象
		ItemBeanSer itemBeanSer = new ItemBeanSer(1000L, 89.9f);
		ItemBean itemBean = new ItemBean(1000L, 89.9f);

		//用于比较String类型和Text类型的序列化差别
		Text atext = new Text("a");
		// atext.write(dout);
		itemBean.write(dout);

		byte[] byteArray = ba.toByteArray();

		//比较序列化结果
		System.out.println(byteArray.length);
		for (byte b : byteArray) {

			System.out.print(b);
			System.out.print(":");
		}

		System.out.println("-----------------------");

		String astr = "a";
		// dout2.writeUTF(astr);
		obout.writeObject(itemBeanSer);

		byte[] byteArray2 = ba2.toByteArray();
		System.out.println(byteArray2.length);
		for (byte b : byteArray2) {
			System.out.print(b);
			System.out.print(":");
		}
	}
}