Hadoop学习笔记: MapReduce(1)

一. MapReduce核心思想

1) 分布式运算程序往往需要分成Map和Reduce两个阶段
2) 第一个阶段的MapTask并发实例, 完全并行运行, 互不相干
3) 第二个阶段的ReduceTask并发实例同样互不相干, 但它们的数据依赖于上一个阶段的所有MapTask并发实例的输出
4) MapReduce编程模型只能包含一个Map和一个Reduce阶段, 如果用户的业务逻辑非常复杂, 那就只能多个MapReudce程序串行执行

MapReduce进程

一个完整的MapReduce程序在分布式运行时有三类实例进程:
1) MrAppMaster: 负责整个程序的过程调度及状态协调
2) MapTask: 负责Map阶段的整个数据处理流程
3) ReduceTask: 负责Reduce阶段的整个数据处理流程

常用数据序列化类型

Java类型	Hadoop Writable类型
Boolean	BooleanWritable
Byte	ByteWritable
Int	Intwritable
Float	FloatWritable
Long	LongWritable
Double	DoubleWritable
String	Text
Map	MapWritable
Array	ArrayWritable
Null	NullWritable

MapReduce编程规范

用户编写的程序分为三个部分: Mapper, Reducer和Driver
1) Mapper阶段
> 用户自定义的Mapper需要继承Map父类
> Mapper的输入数据是(key, value)对的形式(key, value类型可自定义)
> Mapper中的业务逻辑写在map()方法中
> Mapper的输出数据同样是(key, value)的形式
> map()方法(MapTask进程)对每个<key, value>调用一次
2) Reducer阶段
> 用户自定义的Reducer需要继承Reducer父类
> Reducer的输入数据类型对应Mapper的输出数据类型, 也是(key, value)
> Reducer的业务逻辑写在reduce()方法中
> ReduceTask进程对每一组相同键值的(key, value)调用一次reduce()方法
3) Driver阶段
> 相当于Yarn集群的客户端, 用于提交整个程序到Yarn集群, 提交的是封装了MapReduce程序相关运行参数的job对象

二. 案例实操

本地测试环境准备

1) 创建maven工程, MapRduceDemo
2) 在pom.xml文件中添加如下依赖

<dependencies>
    <dependency>
        <groupId>org.apache.hadoop</groupId>
        <artifactId>hadoop-client</artifactId>
        <version>3.1.3</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-log4j12</artifactId>
        <version>1.7.30</version>
    </dependency>
</dependencies>

3) 在项目的src/main/resources目录下, 新建一个文件, 命名为"log4j.properties", 在文件中填入:

log4j.rootLogger=INFO, stdout  
log4j.appender.stdout=org.apache.log4j.ConsoleAppender  
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout  
log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - %m%n  
log4j.appender.logfile=org.apache.log4j.FileAppender  
log4j.appender.logfile.File=target/spring.log  
log4j.appender.logfile.layout=org.apache.log4j.PatternLayout  
log4j.appender.logfile.layout.ConversionPattern=%d %p [%c] - %m%n

 4) 创建包名: com.atguigu.mapreduce.wordcount编写程序
Mapper类

package com.atguigu.mapreduce.wordcount;
import java.io.IOException;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

public class WordCountMapper extends Mapper<LongWritable, Text, Text, IntWritable>{
	
	Text k = new Text();
	IntWritable v = new IntWritable(1);
	
	@Override
	protected void map(LongWritable key, Text value, Context context)	throws IOException, InterruptedException {
		
		// 1 获取一行
		String line = value.toString();
		
		// 2 切割
		String[] words = line.split(" ");
		
		// 3 输出
		for (String word : words) {
			
			k.set(word);
			context.write(k, v);
		}
	}
}

 Reducer类

package com.atguigu.mapreduce.wordcount;
import java.io.IOException;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

public class WordCountReducer extends Reducer<Text, IntWritable, Text, IntWritable>{

int sum;
IntWritable v = new IntWritable();

	@Override
	protected void reduce(Text key, Iterable<IntWritable> values,Context context) throws IOException, InterruptedException {
		
		// 1 累加求和
		sum = 0;
		for (IntWritable count : values) {
			sum += count.get();
		}
		
		// 2 输出
         v.set(sum);
		context.write(key,v);
	}
}

 Driver类

package com.atguigu.mapreduce.wordcount;
import java.io.IOException;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

public class WordCountDriver {

	public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {

		// 1 获取配置信息以及获取job对象
		Configuration conf = new Configuration();
		Job job = Job.getInstance(conf);

		// 2 关联本Driver程序的jar
		job.setJarByClass(WordCountDriver.class);

		// 3 关联Mapper和Reducer的jar
		job.setMapperClass(WordCountMapper.class);
		job.setReducerClass(WordCountReducer.class);

		// 4 设置Mapper输出的kv类型
		job.setMapOutputKeyClass(Text.class);
		job.setMapOutputValueClass(IntWritable.class);

		// 5 设置最终输出kv类型
		job.setOutputKeyClass(Text.class);
		job.setOutputValueClass(IntWritable.class);
		
		// 6 设置输入和输出路径
		FileInputFormat.setInputPaths(job, new Path(args[0]));
		FileOutputFormat.setOutputPath(job, new Path(args[1]));

		// 7 提交job
		boolean result = job.waitForCompletion(true);
		System.exit(result ? 0 : 1);
	}
}

提交至集群测试

1) 用maven打包, 需要添加的插件依赖

<build>
    <plugins>
        <plugin>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.6.1</version>
            <configuration>
                <source>1.8</source>
                <target>1.8</target>
            </configuration>
        </plugin>
        <plugin>
            <artifactId>maven-assembly-plugin</artifactId>
            <configuration>
                <descriptorRefs>
                    <descriptorRef>jar-with-dependencies</descriptorRef>
                </descriptorRefs>
            </configuration>
            <executions>
                <execution>
                    <id>make-assembly</id>
                    <phase>package</phase>
                    <goals>
                        <goal>single</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

 2) 打包完成后, 可在项目目录下的target文件夹中找到已经打包好的jar包, 分为两个, 分别是包含依赖和不包含依赖的jar包.

3) 启动Hadoop集群, 将jar包上传至集群进行执行

[atguigu@hadoop102 hadoop-3.1.3]$ hadoop jar  wc.jar
 com.atguigu.mapreduce.wordcount.WordCountDriver /user/atguigu/input /user/atguigu/output

三. Hadoop序列化

为什么不使用Java序列化?

Java的序列化是一个重量级序列化框架(Serializable), 一个对象被序列化后, 会附带很多额外的信息(校验信息, Header, 继承体系等), 不便于在网络中高效传输. 所以, Hadoop自己开发了一套序列化机制(Writable).
其特点是: (1). 紧凑: 高效使用存储空间; (2). 快速: 读写数据的额外开销小; (3). 互操作: 支持多语言的交互.

自定义bean对象实现序列化接口(Writable)

具体实现bean对象序列化步骤如下7步:
1) 实现Writable接口
2) 反序列化时, 需要反射调用空参构造函数, 所以必须有空参构造

public FlowBean() {
	super();
}

3) 重写序列化方法write()

@Override
public void write(DataOutput out) throws IOException {
	out.writeLong(upFlow);
	out.writeLong(downFlow);
	out.writeLong(sumFlow);
}

4) 重写反序列化方法readFeilds()

@Override
public void readFields(DataInput in) throws IOException {
	upFlow = in.readLong();
	downFlow = in.readLong();
	sumFlow = in.readLong();
}

注意: 反序列化的顺序必须要和序列化的顺序一致
5)  要想把结果显示在文件中, 需要重写toString()方法
6) 如果需要将自定义的bean放在key中传输, 则还需要实现Comparable接口, 因为MapReduce框中的Shuffle过程要求对key必须能排序

@Override
public int compareTo(FlowBean o) {
	// 倒序排列，从大到小
	return this.sumFlow > o.getSumFlow() ? -1 : 1;
}