大数据技术之Hadoop（第3章 MapReduce框架原理）

青旅半醒 2022-12-24 13:00 189阅读 0赞

### 这里写目录标题 ###

*   *  3.8 计数器应用
     *  3.9 数据清洗（ETL）
     *  3.10 数据清洗案例实操
     *   *  3.10.1 简单解析版
         *  3.10.2 复杂解析版
     *  3.11 MapReduce开发总结
 *  第4章 Hadoop数据压缩
 *   *  4.1 概述
     *  4.2 MR支持的压缩编码
     *  4.3 压缩方式选择
     *   *  4.3.1 Gzip压缩
         *  4.3.2 Bzip2压缩
         *  4.3.3 Lzo压缩
         *  4.3.4 Snappy压缩
     *  4.4 压缩位置选择
     *  4.5 压缩参数配置
     *  4.6 压缩实操案例
     *   *  4.6.1 数据流的压缩和解压缩
         *  4.6.2 Map输出端采用压缩
         *  4.6.3 Reduce输出端采用压缩

## 3.8 计数器应用 ##

Hadoop为每个作业维护若干内置计数器，以描述多项指标。例如，某些计数器记录已处理的字节数和记录数，使用户可监控已处理的输入数据量和已产生的输出数据量。  
1．API  
（1）采用枚举的方式统计计数  
enum MyCounter\{MALFORORMED,NORMAL\}  
//对枚举定义的自定义计数器加1  
context.getCounter(MyCounter.MALFORORMED).increment(1);  
（2）采用计数器组、计数器名称的方式统计  
context.getCounter(“counterGroup”, “countera”).increment(1);  
组名和计数器名称随便起，但最好有意义。  
（3）计数结果在程序运行后的控制台上查看。

## 3.9 数据清洗（ETL） ##

ETL是数据抽取（Extract）、清洗（Cleaning）、转换（Transform）、装载（Load）的过程。概述  
在运行核心业务Mapreduce程序之前，往往要先对数据进行清洗，清理掉不符合用户要求的数据。清理的过程往往只需要运行mapper程序，不需要运行reduce程序。

## 3.10 数据清洗案例实操 ##

### 3.10.1 简单解析版 ###

1．需求  
去除日志中字段长度小于等于11的日志。  
2．输入数据  
![在这里插入图片描述][20201128160433474.png]  
3．实现代码  
（1）编写LogMapper

package com.bk.mapreduce.weblog;
    import java.io.IOException;
    import org.apache.hadoop.io.LongWritable;
    import org.apache.hadoop.io.NullWritable;
    import org.apache.hadoop.io.Text;
    import org.apache.hadoop.mapreduce.Mapper;
    
    public class LogMapper extends Mapper<LongWritable, Text, Text, NullWritable>{
        
    	
    	Text k = new Text();
    	
    	@Override
    	protected void map(LongWritable key, Text value, Context context)
    			throws IOException, InterruptedException {
        
    		
    		// 1 获取1行数据
    		String line = value.toString();
    		
    		// 2 解析日志
    		boolean result = parseLog(line,context);
    		
    		// 3 日志不合法退出
    		if (!result) {
        
    			return;
    		}
    		
    		// 4 设置key
    		k.set(line);
    		
    		// 5 写出数据
    		context.write(k, NullWritable.get());
    	}
    
    	// 2 解析日志
    	private boolean parseLog(String line, Context context) {
        
    		// 1 截取
    		String[] fields = line.split(" ");
    		
    		// 2 日志长度大于11的为合法
    		if (fields.length > 11) {
        
    			// 系统计数器
    			context.getCounter("map", "true").increment(1);
    			return true;
    		}else {
        
    			context.getCounter("map", "false").increment(1);
    			return false;
    		}
    	}
    }

（2）编写LogDriver

package com.bk.mapreduce.weblog;
    import org.apache.hadoop.conf.Configuration;
    import org.apache.hadoop.fs.Path;
    import org.apache.hadoop.io.NullWritable;
    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 LogDriver {
        
    
    	public static void main(String[] args) throws Exception {
        
    
            args = new String[] {
         "e:/input/inputlog", "e:/output1" };
    
    		// 1 获取job信息
    		Configuration conf = new Configuration();
    		Job job = Job.getInstance(conf);
    
    		// 2 加载jar包
    		job.setJarByClass(LogDriver.class);
    
    		// 3 关联map
    		job.setMapperClass(LogMapper.class);
    
    		// 4 设置最终输出类型
    		job.setOutputKeyClass(Text.class);
    		job.setOutputValueClass(NullWritable.class);
    
    		// 设置reducetask个数为0
    		job.setNumReduceTasks(0);
    
    		// 5 设置输入和输出路径
    		FileInputFormat.setInputPaths(job, new Path(args[0]));
    		FileOutputFormat.setOutputPath(job, new Path(args[1]));
    
    		// 6 提交
    		job.waitForCompletion(true);
    	}
    }

### 3.10.2 复杂解析版 ###

1．需求  
对web访问日志中的各字段识别切分  
去除日志中不合法的记录  
根据统计需求，生成各类访问请求过滤数据  
2．输入数据  
![在这里插入图片描述][20201128160539559.png]  
3．实现代码  
（1）定义一个bean，用来记录日志数据中的各数据字段

package com.bk.mapreduce.log;
    
    public class LogBean {
        
    	private String remote_addr;// 记录客户端的ip地址
    	private String remote_user;// 记录客户端用户名称,忽略属性"-"
    	private String time_local;// 记录访问时间与时区
    	private String request;// 记录请求的url与http协议
    	private String status;// 记录请求状态；成功是200
    	private String body_bytes_sent;// 记录发送给客户端文件主体内容大小
    	private String http_referer;// 用来记录从那个页面链接访问过来的
    	private String http_user_agent;// 记录客户浏览器的相关信息
    
    	private boolean valid = true;// 判断数据是否合法
    
    	public String getRemote_addr() {
        
    		return remote_addr;
    	}
    
    	public void setRemote_addr(String remote_addr) {
        
    		this.remote_addr = remote_addr;
    	}
    
    	public String getRemote_user() {
        
    		return remote_user;
    	}
    
    	public void setRemote_user(String remote_user) {
        
    		this.remote_user = remote_user;
    	}
    
    	public String getTime_local() {
        
    		return time_local;
    	}
    
    	public void setTime_local(String time_local) {
        
    		this.time_local = time_local;
    	}
    
    	public String getRequest() {
        
    		return request;
    	}
    
    	public void setRequest(String request) {
        
    		this.request = request;
    	}
    
    	public String getStatus() {
        
    		return status;
    	}
    
    	public void setStatus(String status) {
        
    		this.status = status;
    	}
    
    	public String getBody_bytes_sent() {
        
    		return body_bytes_sent;
    	}
    
    	public void setBody_bytes_sent(String body_bytes_sent) {
        
    		this.body_bytes_sent = body_bytes_sent;
    	}
    
    	public String getHttp_referer() {
        
    		return http_referer;
    	}
    
    	public void setHttp_referer(String http_referer) {
        
    		this.http_referer = http_referer;
    	}
    
    	public String getHttp_user_agent() {
        
    		return http_user_agent;
    	}
    
    	public void setHttp_user_agent(String http_user_agent) {
        
    		this.http_user_agent = http_user_agent;
    	}
    
    	public boolean isValid() {
        
    		return valid;
    	}
    
    	public void setValid(boolean valid) {
        
    		this.valid = valid;
    	}
    
    	@Override
    	public String toString() {
        
    		StringBuilder sb = new StringBuilder();
    		sb.append(this.valid);
    		sb.append("\001").append(this.remote_addr);
    		sb.append("\001").append(this.remote_user);
    		sb.append("\001").append(this.time_local);
    		sb.append("\001").append(this.request);
    		sb.append("\001").append(this.status);
    		sb.append("\001").append(this.body_bytes_sent);
    		sb.append("\001").append(this.http_referer);
    		sb.append("\001").append(this.http_user_agent);
    		
    		return sb.toString();
    	}
    }

（2）编写LogMapper程序

package com.bk.mapreduce.log;
    import java.io.IOException;
    import org.apache.hadoop.io.LongWritable;
    import org.apache.hadoop.io.NullWritable;
    import org.apache.hadoop.io.Text;
    import org.apache.hadoop.mapreduce.Mapper;
    
    public class LogMapper extends Mapper<LongWritable, Text, Text, NullWritable>{
        
    	Text k = new Text();
    	
    	@Override
    	protected void map(LongWritable key, Text value, Context context)
    			throws IOException, InterruptedException {
        
    		// 1 获取1行
    		String line = value.toString();
    		
    		// 2 解析日志是否合法
    		LogBean bean = pressLog(line);
    		
    		if (!bean.isValid()) {
        
    			return;
    		}
    		
    		k.set(bean.toString());
    		
    		// 3 输出
    		context.write(k, NullWritable.get());
    	}
    
    	// 解析日志
    	private LogBean pressLog(String line) {
        
    		LogBean logBean = new LogBean();
    		
    		// 1 截取
    		String[] fields = line.split(" ");
    		
    		if (fields.length > 11) {
        
    			// 2封装数据
    			logBean.setRemote_addr(fields[0]);
    			logBean.setRemote_user(fields[1]);
    			logBean.setTime_local(fields[3].substring(1));
    			logBean.setRequest(fields[6]);
    			logBean.setStatus(fields[8]);
    			logBean.setBody_bytes_sent(fields[9]);
    			logBean.setHttp_referer(fields[10]);
    			
    			if (fields.length > 12) {
        
    				logBean.setHttp_user_agent(fields[11] + " "+ fields[12]);
    			}else {
        
    				logBean.setHttp_user_agent(fields[11]);
    			}
    			
    			// 大于400，HTTP错误
    			if (Integer.parseInt(logBean.getStatus()) >= 400) {
        
    				logBean.setValid(false);
    			}
    		}else {
        
    			logBean.setValid(false);
    		}
    		
    		return logBean;
    	}
    }

（3）编写LogDriver程序

package com.bk.mapreduce.log;
    import org.apache.hadoop.conf.Configuration;
    import org.apache.hadoop.fs.Path;
    import org.apache.hadoop.io.NullWritable;
    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 LogDriver {
        
    	public static void main(String[] args) throws Exception {
        
    		// 1 获取job信息
    		Configuration conf = new Configuration();
    		Job job = Job.getInstance(conf);
    
    		// 2 加载jar包
    		job.setJarByClass(LogDriver.class);
    
    		// 3 关联map
    		job.setMapperClass(LogMapper.class);
    
    		// 4 设置最终输出类型
    		job.setOutputKeyClass(Text.class);
    		job.setOutputValueClass(NullWritable.class);
    
    		// 5 设置输入和输出路径
    		FileInputFormat.setInputPaths(job, new Path(args[0]));
    		FileOutputFormat.setOutputPath(job, new Path(args[1]));
    
    		// 6 提交
    		job.waitForCompletion(true);
    	}
    }

## 3.11 MapReduce开发总结 ##

了解mapreduce 执行过程  
精通 mapreduce shuffer 过程.  
在编写mapreduce程序时，需要考虑的几个方面：  
1．输入数据接口：InputFormat  
默认使用的实现类是：TextInputFormat  
TextInputFormat的功能逻辑是：一次读一行文本，然后将该行的起始偏移量作为key，行内容作为value返回。  
KeyValueTextInputFormat每一行均为一条记录，被分隔符分割为key，value。默认分隔符是tab（\\t）。  
NlineInputFormat按照指定的行数N来划分切片。  
CombineTextInputFormat可以把多个小文件合并成一个切片处理，提高处理效率。  
用户还可以自定义InputFormat。  
2．逻辑处理接口：Mapper  
用户根据业务需求实现其中三个方法：map() setup() cleanup ()  
3．Partitioner分区  
有默认实现 HashPartitioner，逻辑是根据key的哈希值和numReduces来返回一个分区号；key.hashCode()&Integer.MAXVALUE % numReduces  
如果业务上有特别的需求，可以自定义分区。  
4．Comparable排序  
当我们用自定义的对象作为key来输出时，就必须要实现WritableComparable接口，重写其中的compareTo()方法。  
部分排序：对最终输出的每一个文件进行内部排序。  
全排序：对所有数据进行排序，通常只有一个Reduce。  
二次排序：排序的条件有两个。  
5．Combiner合并  
Combiner合并可以提高程序执行效率，减少io传输。但是使用时必须不能影响原有的业务处理结果。  
6．reduce端分组：Groupingcomparator  
reduceTask拿到输入数据（一个partition的所有数据）后，首先需要对数据进行分组，其分组的默认原则是key相同，然后对每一组kv数据调用一次reduce()方法，并且将这一组kv中的第一个kv的key作为参数传给reduce的key，将这一组数据的value的迭代器传给reduce()的values参数。  
利用上述这个机制，我们可以实现一个高效的分组取最大值的逻辑。  
自定义一个bean对象用来封装我们的数据，然后改写其compareTo方法产生倒序排序的效果。然后自定义一个Groupingcomparator，将bean对象的分组逻辑改成按照我们的业务分组id来分组（比如订单号）。这样，我们要取的最大值就是reduce()方法中传进来key。  
7．逻辑处理接口：Reducer  
用户根据业务需求实现其中三个方法：reduce() setup() cleanup ()  
8．输出数据接口：OutputFormat  
默认实现类是TextOutputFormat，功能逻辑是：将每一个KV对向目标文本文件中输出为一行。  
SequenceFileOutputFormat将它的输出写为一个顺序文件。如果输出需要作为后续 MapReduce任务的输入，这便是一种好的输出格式，因为它的格式紧凑，很容易被压缩。  
用户还可以自定义OutputFormat。

# 第4章 Hadoop数据压缩 #

## 4.1 概述 ##

压缩技术能够有效减少底层存储系统（HDFS）读写字节数。压缩提高了网络带宽和磁盘空间的效率。在Hadoop下，尤其是数据规模很大和工作负载密集的情况下，使用数据压缩显得非常重要。在这种情况下，I/O操作和网络数据传输要花大量的时间。还有，Shuffle与Merge过程同样也面临着巨大的I/O压力。  
鉴于磁盘I/O和网络带宽是Hadoop的宝贵资源，数据压缩对于节省资源、最小化磁盘I/O和网络传输非常有帮助。不过，尽管压缩与解压操作的CPU开销不高，其性能的提升和资源的节省并非没有代价。  
如果磁盘I/O和网络带宽影响了MapReduce作业性能，在任意MapReduce阶段启用压缩都可以改善端到端处理时间并减少I/O和网络流量。  
压缩Mapreduce的一种优化策略：通过压缩编码对Mapper或者Reducer的输出进行压缩，以减少磁盘IO，提高MR程序运行速度（但相应增加了cpu运算负担）。  
注意：压缩特性运用得当能提高性能，但运用不当也可能降低性能。  
基本原则：  
（1）运算密集型的job，少用压缩  
（2）IO密集型的job，多用压缩

## 4.2 MR支持的压缩编码 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d6cTE4ODQ1MjgwNjEw_size_16_color_FFFFFF_t_70]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d6cTE4ODQ1MjgwNjEw_size_16_color_FFFFFF_t_70 1]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d6cTE4ODQ1MjgwNjEw_size_16_color_FFFFFF_t_70 2]

## 4.3 压缩方式选择 ##

### 4.3.1 Gzip压缩 ###

优点：压缩率比较高，而且压缩/解压速度也比较快；hadoop本身支持，在应用中处理gzip格式的文件就和直接处理文本一样；大部分linux系统都自带gzip命令，使用方便。  
缺点：不支持split。  
应用场景：当每个文件压缩之后在130M以内的（1个块大小内），都可以考虑用gzip压缩格式。例如说一天或者一个小时的日志压缩成一个gzip文件，运行mapreduce程序的时候通过多个gzip文件达到并发。hive程序，streaming程序，和java写的mapreduce程序完全和文本处理一样，压缩之后原来的程序不需要做任何修改。

### 4.3.2 Bzip2压缩 ###

优点：支持split；具有很高的压缩率，比gzip压缩率都高；hadoop本身支持，但不支持native；在linux系统下自带bzip2命令，使用方便。  
缺点：压缩/解压速度慢；不支持native。  
应用场景：适合对速度要求不高，但需要较高的压缩率的时候，可以作为mapreduce作业的输出格式；或者输出之后的数据比较大，处理之后的数据需要压缩存档减少磁盘空间并且以后数据用得比较少的情况；或者对单个很大的文本文件想压缩减少存储空间，同时又需要支持split，而且兼容之前的应用程序（即应用程序不需要修改）的情况。

### 4.3.3 Lzo压缩 ###

优点：压缩/解压速度也比较快，合理的压缩率；支持split，是hadoop中最流行的压缩格式；可以在linux系统下安装lzop命令，使用方便。  
缺点：压缩率比gzip要低一些；hadoop本身不支持，需要安装；在应用中对lzo格式的文件需要做一些特殊处理（为了支持split需要建索引，还需要指定inputformat为lzo格式）。  
应用场景：一个很大的文本文件，压缩之后还大于200M以上的可以考虑，而且单个文件越大，lzo优点越越明显。

### 4.3.4 Snappy压缩 ###

优点：高速压缩速度和合理的压缩率。  
缺点：不支持split；压缩率比gzip要低；hadoop本身不支持，需要安装；  
应用场景：当Mapreduce作业的Map输出的数据比较大的时候，作为Map到Reduce的中间数据的压缩格式；或者作为一个Mapreduce作业的输出和另外一个Mapreduce作业的输入。

## 4.4 压缩位置选择 ##

压缩可以在MapReduce作用的任意阶段启用，如图4-22所示。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d6cTE4ODQ1MjgwNjEw_size_16_color_FFFFFF_t_70 3]

## 4.5 压缩参数配置 ##

要在Hadoop中启用压缩，可以配置如下参数：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d6cTE4ODQ1MjgwNjEw_size_16_color_FFFFFF_t_70 4]

## 4.6 压缩实操案例 ##

### 4.6.1 数据流的压缩和解压缩 ###

CompressionCodec有两个方法可以用于轻松地压缩或解压缩数据。要想对正在被写入一个输出流的数据进行压缩，我们可以使用createOutputStream(OutputStreamout)方法创建一个CompressionOutputStream，将其以压缩格式写入底层的流。相反，要想对从输入流读取而来的数据进行解压缩，则调用createInputStream(InputStreamin)函数，从而获得一个CompressionInputStream从而从底层的流读取未压缩的数据。  
测试一下如下压缩方式：  
![在这里插入图片描述][20201128161223968.png]

package com.bk.mapreduce.compress;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import org.apache.hadoop.conf.Configuration;
    import org.apache.hadoop.fs.Path;
    import org.apache.hadoop.io.IOUtils;
    import org.apache.hadoop.io.compress.CompressionCodec;
    import org.apache.hadoop.io.compress.CompressionCodecFactory;
    import org.apache.hadoop.io.compress.CompressionInputStream;
    import org.apache.hadoop.io.compress.CompressionOutputStream;
    import org.apache.hadoop.util.ReflectionUtils;
    
    public class TestCompress {
        
    
    	public static void main(String[] args) throws Exception {
        
    		compress("e:/hello.txt","org.apache.hadoop.io.compress.BZip2Codec");
    //		decompress("e:/hello.txt.bz2");
    	}
    
    	// 压缩
    	private static void compress(String filename, String method) throws Exception {
        
    		
    		// 1 获取输入流
    		FileInputStream fis = new FileInputStream(new File(filename));
    		
    		Class codecClass = Class.forName(method);
    		
    		CompressionCodec codec = (CompressionCodec) ReflectionUtils.newInstance(codecClass, new Configuration());
    		
    		// 2 获取输出流
    		FileOutputStream fos = new FileOutputStream(new File(filename +codec.getDefaultExtension()));
    		CompressionOutputStream cos = codec.createOutputStream(fos);
    		
    		// 3 流的对拷
    		IOUtils.copyBytes(fis, cos, 1024*1024*5, false);
    		
    		// 4 关闭资源
    		fis.close();
    		cos.close();
    		fos.close();
    	}
    
    	// 解压缩
    	private static void decompress(String filename) throws FileNotFoundException, IOException {
        
    		
    		// 0 校验是否能解压缩
    		CompressionCodecFactory factory = new CompressionCodecFactory(new Configuration());
    		CompressionCodec codec = factory.getCodec(new Path(filename));
    		
    		if (codec == null) {
        
    			System.out.println("cannot find codec for file " + filename);
    			return;
    		}
    		
    		// 1 获取输入流
    		CompressionInputStream cis = codec.createInputStream(new FileInputStream(new File(filename)));
    		
    		// 2 获取输出流
    		FileOutputStream fos = new FileOutputStream(new File(filename + ".decoded"));
    		
    		// 3 流的对拷
    		IOUtils.copyBytes(cis, fos, 1024*1024*5, false);
    		
    		// 4 关闭资源
    		cis.close();
    		fos.close();
    	}
    }

### 4.6.2 Map输出端采用压缩 ###

即使你的MapReduce的输入输出文件都是未压缩的文件，你仍然可以对map任务的中间结果输出做压缩，因为它要写在硬盘并且通过网络传输到reduce节点，对其压缩可以提高很多性能，这些工作只要设置两个属性即可，我们来看下代码怎么设置：  
1．给大家提供的hadoop源码支持的压缩格式有：BZip2Codec 、DefaultCodec

package com.bk.mapreduce.compress;
    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.io.compress.BZip2Codec;	
    import org.apache.hadoop.io.compress.CompressionCodec;
    import org.apache.hadoop.io.compress.GzipCodec;
    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 {
        
    
    		Configuration configuration = new Configuration();
    
    		// 开启map端输出压缩
    		configuration.setBoolean("mapreduce.map.output.compress", true);
    		// 设置map端输出压缩方式
    		configuration.setClass("mapreduce.map.output.compress.codec", BZip2Codec.class, CompressionCodec.class);
    
    		Job job = Job.getInstance(configuration);
    
    		job.setJarByClass(WordCountDriver.class);
    
    		job.setMapperClass(WordCountMapper.class);
    		job.setReducerClass(WordCountReducer.class);
    
    		job.setMapOutputKeyClass(Text.class);
    		job.setMapOutputValueClass(IntWritable.class);
    
    		job.setOutputKeyClass(Text.class);
    		job.setOutputValueClass(IntWritable.class);
    
    		FileInputFormat.setInputPaths(job, new Path(args[0]));
    		FileOutputFormat.setOutputPath(job, new Path(args[1]));
    
    		boolean result = job.waitForCompletion(true);
    
    		System.exit(result ? 1 : 0);
    	}
    }

2．Mapper保持不变

package com.bk.mapreduce.compress;
    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>{
        
    	
    	@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){
        
    			context.write(new Text(word), new IntWritable(1));
    		}
    	}
    }

3．Reducer保持不变

package com.bk.mapreduce.compress;
    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>{
        
    	
    	@Override
    	protected void reduce(Text key, Iterable<IntWritable> values,
    			Context context) throws IOException, InterruptedException {
        
    		
    		int count = 0;
    		// 1 汇总
    		for(IntWritable value:values){
        
    			count += value.get();
    		}
    		
            // 2 输出
    		context.write(key, new IntWritable(count));
    	}
    }

### 4.6.3 Reduce输出端采用压缩 ###

基于workcount案例处理  
1．修改驱动

package com.bk.mapreduce.compress;
    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.io.compress.BZip2Codec;
    import org.apache.hadoop.io.compress.DefaultCodec;
    import org.apache.hadoop.io.compress.GzipCodec;
    import org.apache.hadoop.io.compress.Lz4Codec;
    import org.apache.hadoop.io.compress.SnappyCodec;
    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 {
        
    		
    		Configuration configuration = new Configuration();
    		
    		Job job = Job.getInstance(configuration);
    		
    		job.setJarByClass(WordCountDriver.class);
    		
    		job.setMapperClass(WordCountMapper.class);
    		job.setReducerClass(WordCountReducer.class);
    		
    		job.setMapOutputKeyClass(Text.class);
    		job.setMapOutputValueClass(IntWritable.class);
    		
    		job.setOutputKeyClass(Text.class);
    		job.setOutputValueClass(IntWritable.class);
    		
    		FileInputFormat.setInputPaths(job, new Path(args[0]));
    		FileOutputFormat.setOutputPath(job, new Path(args[1]));
    		
    		// 设置reduce端输出压缩开启
    		FileOutputFormat.setCompressOutput(job, true);
    		
    		// 设置压缩的方式
    	    FileOutputFormat.setOutputCompressorClass(job, BZip2Codec.class); 
    //	    FileOutputFormat.setOutputCompressorClass(job, GzipCodec.class); 
    //	    FileOutputFormat.setOutputCompressorClass(job, DefaultCodec.class); 
    	    
    		boolean result = job.waitForCompletion(true);
    		
    		System.exit(result?1:0);
    	}
    }
    
    
    snappy 压缩格式:
    // 设置压缩的方式
    conf.set("mapreduce.output.fileoutputformat.compress","true");
    
    conf.set("mapreduce.output.fileoutputformat.compress.type","RECORD");
    
    conf.set("mapreduce.output.fileoutputformat.compress.codec","org.apache.hadoop.io.compress.SnappyCodec");

2．Mapper和Reducer保持不变（详见4.6.2）

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

**下一章我们要讲【5.1 Yarn概述】end！！！！**

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

[20201128160433474.png]: /images/20221120/2b51f8a49a0046299f622c461350d4f4.png
[20201128160539559.png]: https://img-blog.csdnimg.cn/20201128160539559.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d6cTE4ODQ1MjgwNjEw_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20201128160804835.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d6cTE4ODQ1MjgwNjEw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d6cTE4ODQ1MjgwNjEw_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20201128160813484.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d6cTE4ODQ1MjgwNjEw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d6cTE4ODQ1MjgwNjEw_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20201128160828634.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d6cTE4ODQ1MjgwNjEw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d6cTE4ODQ1MjgwNjEw_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20201128161022280.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d6cTE4ODQ1MjgwNjEw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d6cTE4ODQ1MjgwNjEw_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/2020112816110082.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d6cTE4ODQ1MjgwNjEw,size_16,color_FFFFFF,t_70
[20201128161223968.png]: https://img-blog.csdnimg.cn/20201128161223968.png