【Hadoop-快速理解MapReduce原理】

最新推荐文章于 2024-06-15 06:34:12 发布
最新推荐文章于 2024-06-15 06:34:12 发布
阅读量817 收藏 20
点赞数 21
文章标签： hadoop mapreduce 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangqw1013/article/details/135083211
版权

文章目录

前言

MapReduce是一个分布式运算程序的编程框架，MapReduce核心功能是将用户编写的业务逻辑代码和自带默认组件整合成一个完整的分布式运算程序，并发运行在一个Hadoop集群上。

一、MapReduce优缺点

1、优点

1）MapReduce易于编程
它简单的实现一些接口，就可以完成一个分布式程序，这个分布式程序可以分布到大量廉价的PC机器上运行。也就是说你写一个分布式程序，跟写一个简单的串行程序是一模一样的。就是因为这个特点使得MapReduce编程变得非常流行。

2）良好的扩展性
当你的计算资源不能得到满足的时候，你可以通过简单的增加机器来扩展它的计算能力。

3）高容错性
MapReduce设计的初衷就是使程序能够部署在廉价的PC机器上，这就要求它具有很高的容错性。比如其中一台机器挂了，它可以把上面的计算任务转移到另外一个节点上运行，不至于这个任务运行失败，而且这个过程不需要人工参与，而完全是由Hadoop内部完成的。

4）适合PB级以上海量数据的离线处理
可以实现上千台服务器集群并发工作，提供数据处理能力。

2、缺点

1）不擅长实时计算
MapReduce无法像MySQL一样，在毫秒或者秒级内返回结果。

2）不擅长流式计算
流式计算的输入数据是动态的，而MapReduce的输入数据集是静态的，不能动态变化。这是因为MapReduce自身的设计特点决定了数据源必须是静态的。

3）不擅长DAG（有向无环图）计算
多个应用程序存在依赖关系，后一个应用程序的输入为前一个的输出。在这种情况下，MapReduce并不是不能做，而是使用后，每个MapReduce作业的输出结果都会写入到磁盘，会造成大量的磁盘IO，导致性能非常的低下。

二、MapReduce介绍

1、核心思想

（1）分布式的运算程序往往需要分成至少2个阶段。
（2）第一个阶段的MapTask并发实例，完全并行运行，互不相干。
（3）第二个阶段的ReduceTask并发实例互不相干，但是他们的数据依赖于上一个阶段的所有MapTask并发实例的输出。
（4）MapReduce编程模型只能包含一个Map阶段和一个Reduce阶段，如果用户的业务逻辑非常复杂，那就只能多个MapReduce程序，串行运行。
总结：分析WordCount数据流走向深入理解MapReduce核心思想。

2、MapReduce进程

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

3、案例：

需求：统计一堆文件中单词出现的个数（WordCount案例）
1、输入数据
2、将MapTask传给我们的文本内容先转换成String（Mapper）
3、根据空格将这一行切分成单词（Mapper）
4、将单词输出为<单词，1>（Mapper）
5、汇总各个key的个数（Reducer）
6、输出该key的总次数（Reducer）
7、准备Driver

4、代码

1、pom文件中添加依赖

		<dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-client</artifactId>
            <version>3.1.3</version>
        </dependency>

2、编写Mapper

/**
 * 4个泛型
 * KEYIN LongWritable,用来表示偏移量（从文件的哪个位置读取数据）
 * VALUEIN Text，从文件中读取到的数据
 *
 * KEYOUT Text 单词
 * VALUEOUT IntWritable 单词出现的次数
 */
public class WordCountMapper extends Mapper<LongWritable, Text,Text, IntWritable> {

    private Text outKey = new Text();
    private IntWritable outV = new IntWritable(1);
    /**
     *
     * @param key 偏移量
     * @param value 读取到的一行数据
     * @param context 上下文对象，调度Mapper类中方法的执行
     * @throws IOException
     * @throws InterruptedException
     */
    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        String lineWrod = value.toString();
        String[] words = lineWrod.split(" ");
        for (String word : words) {
            outKey.set(word);
            context.write(outKey,outV);
        }
    }
}

3、编写Reduce

/**
 * 4个泛型
 * KEYIN Text,输入数据key的类型
 * VALUEIN IntWritable，输入数据v类型
 *
 * KEYOUT Text shu chu shu jv key lei xing
 * VALUEOUT IntWritable shu chu shu jv v lei xing
 */
public class WordCountReducer extends Reducer<Text, IntWritable,Text,IntWritable> {
    private IntWritable outV = new IntWritable();
    /**
     * 相同k的多个kv对 会执行一次reduce方法
     * @param key 输入数据key的类型
     * @param values 输入key所有对应的v
     * @param context
     * @throws IOException
     * @throws InterruptedException
     */
    @Override
    protected void reduce(Text key, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException {
        int sum = 0;
        for (IntWritable value : values) {
            sum += value.get();
        }
        outV.set(sum);
        context.write(key,outV);
    }
}

4、编写Driver

public class WordCountDriver {
    public static void main(String[] args) throws IOException, InterruptedException, ClassNotFoundException {
        //创建p配置对象
        Configuration configuration = new Configuration();
        //创建JOB对象
        Job job = Job.getInstance(configuration);
        //关联驱动类
        job.setJarByClass(WordCountDriver.class);
        //关联Mapper和Reducer类
        job.setMapperClass(WordCountMapper.class);
        job.setReducerClass(WordCountReducer.class);
        //设置mapper key和value 输出的类型
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(IntWritable.class);
        //设置最终key和value 输出的类型
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(IntWritable.class);
        //设置输入、输出路径
        FileInputFormat.setInputPaths(job,new Path(args[0]));
        FileOutputFormat.setOutputPath(job,new Path(args[1]));
        //提交JOB
        job.waitForCompletion(true);
    }
}

5、打包部署到Hadoop集群测试

hadoop jar  wordcount.jar  com.zqw.mapreduce.wordcount.WordCountDriver /user/zqw/input /user/zqw/output

三、Hadoop序列化

1、序列化介绍

序列化就是把内存中的对象，转换成字节序列（或其他数据传输协议）以便于存储到磁盘（持久化）和网络传输。

反序列化就是将收到字节序列（或其他数据传输协议）或者是磁盘的持久化数据，转换成内存中的对象。

Java的序列化是一个重量级序列化框架（Serializable），一个对象被序列化后，会附带很多额外的信息（各种校验信息，Header，继承体系等），不便于在网络中高效传输。所以，Hadoop自己开发了一套序列化机制（Writable）。

Hadoop序列化特点：
（1）紧凑 ：高效使用存储空间。
（2）快速：读写数据的额外开销小。
（3）互操作：支持多语言的交互

2、自定义bean对象实现序列化接口（Writable）

在企业开发中往往常用的基本序列化类型不能满足所有需求，比如在Hadoop框架内部传递一个bean对象，那么该对象就需要实现序列化接口。
具体实现bean对象序列化步骤如下7步。
（1）必须实现Writable接口
（2）反序列化时，需要反射调用空参构造函数，所以必须有空参构造

public FlowBean() {
	super();
}

（3）重写序列化方法

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

（4）重写反序列化方法

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

（5）注意反序列化的顺序和序列化的顺序完全一致
（6）要想把结果显示在文件中，需要重写toString()，可用"\t"分开，方便后续用。
（7）如果需要将自定义的bean放在key中传输，则还需要实现Comparable接口，因为MapReduce框中的Shuffle过程要求对key必须能排序。详见后面排序案例。

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

3、案例代码

需求：统计每一个手机号耗费的总上行流量、总下行流量、总流量

输入数据格式：

id手机号码网络ip上行流量下行流量网络状态码
713560436666120.196.100.991116954200

输出数据格式：

手机号码上行流量下行流量总流量
1356043666611169542070

（1）编写流量统计的Bean对象

//1 继承Writable接口
public class FlowBean implements Writable {

    private long upFlow; //上行流量
    private long downFlow; //下行流量
    private long sumFlow; //总流量

    //2 提供无参构造
    public FlowBean() {
    }

    //3 提供三个参数的getter和setter方法
    public long getUpFlow() {
        return upFlow;
    }

    public void setUpFlow(long upFlow) {
        this.upFlow = upFlow;
    }

    public long getDownFlow() {
        return downFlow;
    }

    public void setDownFlow(long downFlow) {
        this.downFlow = downFlow;
    }

    public long getSumFlow() {
        return sumFlow;
    }

    public void setSumFlow(long sumFlow) {
        this.sumFlow = sumFlow;
    }

    public void setSumFlow() {
        this.sumFlow = this.upFlow + this.downFlow;
    }

    //4 实现序列化和反序列化方法,注意顺序一定要保持一致
    @Override
    public void write(DataOutput dataOutput) throws IOException {
        dataOutput.writeLong(upFlow);
        dataOutput.writeLong(downFlow);
        dataOutput.writeLong(sumFlow);
    }

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

    //5 重写ToString
    @Override
    public String toString() {
        return upFlow + "\t" + downFlow + "\t" + sumFlow;
    }
}

（2）编写Mapper类

public class FlowMapper extends Mapper<LongWritable, Text, Text, FlowBean> {
    private Text outK = new Text();
    private FlowBean outV = new FlowBean();

    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {

        //1 获取一行数据,转成字符串
        String line = value.toString();

        //2 切割数据
        String[] split = line.split("\t");

        //3 抓取我们需要的数据:手机号,上行流量,下行流量
        String phone = split[1];
        String up = split[split.length - 3];
        String down = split[split.length - 2];

        //4 封装outK outV
        outK.set(phone);
        outV.setUpFlow(Long.parseLong(up));
        outV.setDownFlow(Long.parseLong(down));
        outV.setSumFlow();

        //5 写出outK outV
        context.write(outK, outV);
    }
}

（3）编写Reducer类

public class FlowReducer extends Reducer<Text, FlowBean, Text, FlowBean> {
    private FlowBean outV = new FlowBean();
    @Override
    protected void reduce(Text key, Iterable<FlowBean> values, Context context) throws IOException, InterruptedException {

        long totalUp = 0;
        long totalDown = 0;

        //1 遍历values,将其中的上行流量,下行流量分别累加
        for (FlowBean flowBean : values) {
            totalUp += flowBean.getUpFlow();
            totalDown += flowBean.getDownFlow();
        }

        //2 封装outKV
        outV.setUpFlow(totalUp);
        outV.setDownFlow(totalDown);
        outV.setSumFlow();

        //3 写出outK outV
        context.write(key,outV);
    }
}

（4）编写Driver驱动类

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

        //1 获取job对象
        Configuration conf = new Configuration();
        Job job = Job.getInstance(conf);

        //2 关联本Driver类
        job.setJarByClass(FlowDriver.class);

        //3 关联Mapper和Reducer
        job.setMapperClass(FlowMapper.class);
        job.setReducerClass(FlowReducer.class);
        
		//4 设置Map端输出KV类型
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(FlowBean.class);
        
		//5 设置程序最终输出的KV类型
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(FlowBean.class);
        
		//6 设置程序的输入输出路径
        FileInputFormat.setInputPaths(job, new Path("D:\\inputflow"));
        FileOutputFormat.setOutputPath(job, new Path("D:\\flowoutput"));
        
		//7 提交Job
        boolean b = job.waitForCompletion(true);
        System.exit(b ? 0 : 1);
    }
}

四、MapReduce框架原理

1、InputFormat数据输入

MapTask的并行度决定Map阶段的任务处理并发度，进而影响到整个Job的处理速度。
思考：1G的数据，启动8个MapTask，可以提高集群的并发处理能力。那么1K的数据，也启动8个MapTask，会提高集群性能吗？

MapTask并行度决定机制
数据块：Block是HDFS物理上把数据分成一块一块。数据块是HDFS存储数据单位。
数据切片：数据切片只是在逻辑上对输入进行分片，并不会在磁盘上将其切分成片进行存储。数据切片是MapReduce程序计算输入数据的单位，一个切片会对应启动一个MapTask。

2、FileInputFormat切片机制

（1）简单地按照文件的内容长度进行切片
（2）切片大小，默认等于Block大小（128M）
（3）切片时不考虑数据集整体，而是逐个针对每一个文件单独切片

	例如：输入两个文件
	file1.txt    320M
	file2.txt    10M
	
	经过FileInputFormat的切片机制运算后，形成的切片信息如下：
	file1.txt.split1--  0~128
	file1.txt.split2--  128~256
	file1.txt.split3--  256~320
	file2.txt.split1--  0~10M

3、TextInputFormat

思考：在运行MapReduce程序时，输入的文件格式包括：基于行的日志文件、二进制格式文件、数据库表等。那么，针对不同的数据类型，MapReduce是如何读取这些数据的呢？

FileInputFormat常见的接口实现类包括：TextInputFormat、KeyValueTextInputFormat、NLineInputFormat、CombineTextInputFormat和自定义InputFormat等。

TextInputFormat是默认的FileInputFormat实现类。按行读取每条记录。键是存储该行在整个文件中的起始字节偏移量， LongWritable类型。值是这行的内容，不包括任何行终止符（换行符和回车符），Text类型。

以下是一个示例，比如，一个分片包含了如下4条文本记录。

Rich learning form
Intelligent learning engine
Learning more convenient
From the real demand for more close to the enterprise

每条记录表示为以下键/值对：

(0,Rich learning form)
(20,Intelligent learning engine)
(49,Learning more convenient)
(74,From the real demand for more close to the enterprise)

4、CombineTextInputFormat切片机制

框架默认的TextInputFormat切片机制是对任务按文件规划切片，不管文件多小，都会是一个单独的切片，都会交给一个MapTask，这样如果有大量小文件，就会产生大量的MapTask，处理效率极其低下。CombineTextInputFormat用于小文件过多的场景，它可以将多个小文件从逻辑上规划到一个切片中，这样，多个小文件就可以交给一个MapTask处理。

1）虚拟存储过程：
将输入目录下所有文件大小，依次和设置的setMaxInputSplitSize值比较，如果不大于设置的最大值，逻辑上划分一个块。如果输入文件大于设置的最大值且大于两倍，那么以最大值切割一块；当剩余数据大小超过设置的最大值且不大于最大值2倍，此时将文件均分成2个虚拟存储块（防止出现太小切片）。
例如：
setMaxInputSplitSize值为4M，输入文件大小为8.02M，则先逻辑上分成一个4M。剩余的大小为4.02M，如果按照4M逻辑划分，就会出现0.02M的小的虚拟存储文件，所以将剩余的4.02M文件切分成（2.01M和2.01M）两个文件。

2）切片过程：
（1）判断虚拟存储的文件大小是否大于setMaxInputSplitSize值，大于等于则单独形成一个切片。
（2）如果不大于则跟下一个虚拟存储文件进行合并，共同形成一个切片。
例如：
有4个小文件大小分别为1.7M、5.1M、3.4M以及6.8M这四个小文件，则虚拟存储之后形成6个文件块，大小分别为：1.7M，（2.55M、2.55M），3.4M以及（3.4M、3.4M）
最终会形成3个切片，大小分别为：（1.7+2.55）M，（2.55+3.4）M，（3.4+3.4）M

在这里插入图片描述
代码实现：
驱动类中添加代码

// 如果不设置InputFormat，它默认用的是TextInputFormat.class
job.setInputFormatClass(CombineTextInputFormat.class);

//虚拟存储切片最大值设置4m
CombineTextInputFormat.setMaxInputSplitSize(job, 4194304);

5、Shuffle机制

Map方法之后，Reduce方法之前的数据处理过程称之为Shuffle。

（1）MapTask收集map()方法输出的kv对，放到内存缓冲区中
（2）从内存缓冲区不断溢出本地磁盘文件，可能会溢出多个文件
（3）多个溢出文件会被合并成大的溢出文件
（4）在溢出过程及合并的过程中，都要调用Partitioner进行分区和针对key进行排序
（5）ReduceTask根据自己的分区号，去各个MapTask机器上取相应的结果分区数据
（6）ReduceTask会抓取到同一个分区的来自不同MapTask的结果文件，ReduceTask会将这些文件再进行合并（归并排序）
（7）合并成大文件后，Shuffle的过程也就结束了，后面进入ReduceTask的逻辑运算过程（从文件中取出一个一个的键值对Group，调用用户自定义的reduce()方法）
注意：
（1）Shuffle中的缓冲区大小会影响到MapReduce程序的执行效率，原则上说，缓冲区越大，磁盘io的次数越少，执行速度就越快。
（2）缓冲区的大小可以通过参数调整，参数：mapreduce.task.io.sort.mb默认100M。
在这里插入图片描述

6、Partition分区

要求将统计结果按照条件输出到不同文件中（分区）。比如：将统计结果按照手机归属地不同省份输出到不同文件中（分区）
默认分区是根据key的hashCode对ReduceTasks个数取模得到的。用户没法控制哪个key存储到哪个分区。
代码实现：

继承类，指定分区规则。例如一下是按照手机号开头三位确定分区

public class FlowPartitioner extends Partitioner<Text,FlowBean> {
    @Override
    public int getPartition(Text text, FlowBean flowBean, int numPartitions) {
        String phoneNo = text.toString();
        int partition;
        if(phoneNo.startsWith("136")){
            partition = 0;
        }else if (phoneNo.startsWith("137")){
            partition = 1;
        }else if (phoneNo.startsWith("138")){
            partition = 2;
        }else if (phoneNo.startsWith("139")){
            partition = 3;
        }else {
            partition = 4;
        }
        return partition;
    }
}

driver类中增加指定分区和Reduce个数代码

		//设置分区
        job.setPartitionerClass(FlowPartitioner.class);
        //设置reduce的个数
        job.setNumReduceTasks(5);

结论：
（1）如果ReduceTask的数量> getPartition的结果数，则会多产生几个空的输出文件part-r-000xx；
（2）如果1<ReduceTask的数量<getPartition的结果数，则有一部分分区数据无处安放，会Exception；
（3）如果ReduceTask的数量=1，则不管MapTask端输出多少个分区文件，最终结果都交给这一个ReduceTask，最终也就只会产生一个结果文件 part-r-00000；
（4）分区号必须从零开始，逐一累加。

7、 WritableComparable排序

对于MapTask，它会将处理的结果暂时放到环形缓冲区中，当环形缓冲区使用率达到一定阈值后，再对缓冲区中的数据进行一次快速排序，并将这些有序数据溢写到磁盘上，而当数据处理完毕后，它会对磁盘上所有文件进行归并排序。
对于ReduceTask，它从每个MapTask上远程拷贝相应的数据文件，如果文件大小超过一定阈值，则溢写磁盘上，否则存储在内存中。如果磁盘上文件数目达到一定阈值，则进行一次归并排序以生成一个更大文件；如果内存中文件大小或者数目超过一定阈值，则进行一次合并后将数据溢写到磁盘上。当所有数据拷贝完毕后，ReduceTask统一对内存和磁盘上的所有数据进行一次归并排序。

bean对象做为key传输，需要实现WritableComparable接口重写compareTo方法，就可以实现排序。

 @Override
    public int compareTo(FlowBean o) {
        //按照总流量比较,倒序排列
        if(this.sumFlow > o.sumFlow){
            return -1;
        }else if(this.sumFlow < o.sumFlow){
            return 1;
        }else {
            return 0;
        }
    }

8、Combiner合并

Combiner是MR程序中Mapper和Reducer之外的一种组件。Combiner是在每一个MapTask所在的节点运行;Reducer是接收全局所有Mapper的输出结果；Combiner的意义就是对每一个MapTask的输出进行局部汇总，以减小网络传输量。Combiner能够应用的前提是不能影响最终的业务逻辑，而且，Combiner的输出kv应该跟Reducer的输入kv类型要对应起来。

案例：
1、创建WordCombiner

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

    Text outKey = new Text();
    IntWritable outV = new IntWritable();

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

2、在Driver中指定Combiner

        //指定Combiner
        job.setCombinerClass(WordCombiner.class);

3、输出结果

	Map-Reduce Framework
	Map input records=7
	Map output records=10
	Map output bytes=95
	Map output materialized bytes=88
	Input split bytes=83
	Combine input records=10
	Combine output records=7
	Reduce input groups=7
	Reduce shuffle bytes=88
	Reduce input records=7

9、OutputFormat数据输出

OutputFormat是MapReduce输出的基类，所有实现MapReduce输出都实现了 OutputFormat接口。默认输出格式TextOutputFormat

自定义OutputFormat
1、自定义一个类继承FileOutputFormat。
2、改写RecordWriter，具体改写输出数据的方法write()。

案例：
需求：过滤输入的log日志，包含org的网站输出到e:/org.log，不包含arg的网站输出到e:/other.log。
1、创建Mapper

public class LoggerMapper extends Mapper<LongWritable, Text,Text,NullWritable> {
    Text outKey = new Text();
    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        String line = value.toString();
        outKey.set(line);
        context.write(outKey,NullWritable.get());
    }
}

2、创建Reduce

public class LogReduce extends Reducer<Text, NullWritable,Text,NullWritable> {
    @Override
    protected void reduce(Text key, Iterable<NullWritable> values, Context context) throws IOException, InterruptedException {
        for (NullWritable value : values) {
            context.write(key,NullWritable.get());
        }
    }
}

3、创建LoggerRecordWriter

public class LogRecordWriter extends RecordWriter<Text, NullWritable> {

    private FSDataOutputStream isDir = null;
    private FSDataOutputStream otherDir = null;

    public LogRecordWriter(TaskAttemptContext job){
        try {
            FileSystem fileSystem = FileSystem.get(job.getConfiguration());
            isDir = fileSystem.create(new Path(("E://org.log")));
            otherDir = fileSystem.create(new Path(("E://other.log")));
        }catch (Exception e){

        }
    }


    @Override
    public void write(Text key, NullWritable value) throws IOException, InterruptedException {
        String url = key.toString();
        if(url.contains("arg")){
            isDir.writeBytes(key + "\n");
        }else {
            otherDir.writeBytes(key + "\n");
        }
    }

    @Override
    public void close(TaskAttemptContext context) throws IOException, InterruptedException {
        IOUtils.closeStream(isDir);
        IOUtils.closeStream(otherDir);
    }
}

4、创建LogOutputFormat

public class LogOutputFormat extends FileOutputFormat<Text, NullWritable> {
    @Override
    public RecordWriter<Text, NullWritable> getRecordWriter(TaskAttemptContext job) throws IOException, InterruptedException {
        LogRecordWriter logRecordWriter = new LogRecordWriter(job);
        return logRecordWriter;
    }
}

5、编写Driver

public class LogDriver {
    public static void main(String[] args) throws IOException, InterruptedException, ClassNotFoundException {
        Configuration configuration = new Configuration();
        Job job = Job.getInstance(configuration);
        job.setJarByClass(LogDriver.class);
        job.setMapperClass(LoggerMapper.class);
        job.setReducerClass(LogReduce.class);
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(NullWritable.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(NullWritable.class);
        // 设置输出格式
        job.setOutputFormatClass(LogOutputFormat.class);
        FileInputFormat.setInputPaths(job,new Path("E://log.txt"));
        FileOutputFormat.setOutputPath(job,new Path("E://output2"));
        boolean b = job.waitForCompletion(true);
        System.exit(b?0:1);
    }
}

五、Hadoop数据压缩

1、简介

1）压缩的好处和坏处
压缩的优点：以减少磁盘IO、减少磁盘存储空间。
压缩的缺点：增加CPU开销。
2）压缩原则
（1）运算密集型的Job，少用压缩
（2）IO密集型的Job，多用压缩

2、MR支持的压缩编码

压缩格式Hadoop自带？算法文件扩展名是否可切片换成压缩格式后，原来的程序是否需要修改
DEFLATE是，直接使用DEFLATE.deflate否和文本处理一样，不需要修改
Gzip是，直接使用DEFLATE.gz否和文本处理一样，不需要修改
bzip2是，直接使用bzip2.bz2是和文本处理一样，不需要修改
LZO否，需要安装LZO.lzo是需要建索引，还需要指定输入格式
Snappy是，直接使用Snappy.snappy否和文本处理一样，不需要修改

压缩性能的比较

压缩算法原始文件大小压缩文件大小压缩速度解压速度
gzip8.3GB1.8GB17.5MB/s58MB/s
bzip28.3GB1.1GB2.4MB/s9.5MB/s
LZO8.3GB2.9GB49.3MB/s74.6MB/s

压缩方式选择时重点考虑：压缩/解压缩速度、压缩率（压缩后存储大小）、压缩后是否可以支持切片。
Gzip压缩
优点：压缩率比较高；
缺点：不支持Split；压缩/解压速度一般；
Bzip2压缩
优点：压缩率高；支持Split；
缺点：压缩/解压速度慢。
Lzo压缩
优点：压缩/解压速度比较快；支持Split；
缺点：压缩率一般；想支持切片需要额外创建索引。
Snappy压缩
优点：压缩和解压缩速度快；
缺点：不支持Split；压缩率一般；

压缩可以在MapReduce作用的任意阶段启用。
Mapper端启用压缩

		// 开启map端输出压缩
		conf.setBoolean("mapreduce.map.output.compress", true);

		// 设置map端输出压缩方式
		conf.setClass("mapreduce.map.output.compress.codec", BZip2Codec.class,CompressionCodec.class);

Reduce端启用压缩

		// 设置reduce端输出压缩开启
		FileOutputFormat.setCompressOutput(job, true);

		// 设置压缩的方式
	    FileOutputFormat.setOutputCompressorClass(job, BZip2Codec.class);

总结

1）输入数据接口：InputFormat
（1）默认使用的实现类是：TextInputFormat
（2）TextInputFormat的功能逻辑是：一次读一行文本，然后将该行的起始偏移量作为key，行内容作为value返回。
（3）CombineTextInputFormat可以把多个小文件合并成一个切片处理，提高处理效率。
2）逻辑处理接口：Mapper
用户根据业务需求实现其中三个方法：map() setup() cleanup ()
3）Partitioner分区
（1）有默认实现 HashPartitioner，逻辑是根据key的哈希值和numReduces来返回一个分区号；key.hashCode()&Integer.MAXVALUE % numReduces
（2）如果业务上有特别的需求，可以自定义分区。
4）Comparable排序
（1）当我们用自定义的对象作为key来输出时，就必须要实现WritableComparable接口，重写其中的compareTo()方法。
（2）部分排序：对最终输出的每一个文件进行内部排序。
（3）全排序：对所有数据进行排序，通常只有一个Reduce。
（4）二次排序：排序的条件有两个。
5）Combiner合并
Combiner合并可以提高程序执行效率，减少IO传输。但是使用时必须不能影响原有的业务处理结果。
6）逻辑处理接口：Reducer
用户根据业务需求实现其中三个方法：reduce() setup() cleanup ()
7）输出数据接口：OutputFormat
（1）默认实现类是TextOutputFormat，功能逻辑是：将每一个KV对，向目标文本文件输出一行。
（2）用户还可以自定义OutputFormat。

zhangqw1013
关注
  • 21
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Hadoop-MapReduce原理及操作（小实验）
qq_28840013的博客
03-30 2083
本篇博客原理部分摘取自视频http://yun.itheima.com/course/301.html 实验部分教程来自https://www.shiyanlou.com/courses/237 （如果有不理解的可以直接查看上面的链接，另外说一下，该博客只能帮助你理解mapreduce的原理，如果你接触过相关开发的话，本博客可能并不能给你带来帮助。） MapReduce思想 MapReduce思想...
Hadoop学习--深入理解MapReduce
乔治在哪里
09-04 456
目录 1.概述 2.Map 2.1 工作原理 2.2 如何进行分布式处理 3.Reduce 3.1 一个Reduce的情况 3.2 多个Reduce 4.Combiner函数 4.1 combiner函数的原理 4.2 combiner函数的限制 1.概述 MapReduce是一个用java编写的分布式的计算编程框架，其主要由三个组件构成，分别为Map、Reduce和负责调...
Hadoop-MapReduce的工作原理
ThinkDoc.vip
05-11 458
是我见我最全最清楚的剖析MapReduce的文章，，提供项目实例对运行机制的理解，非常容易理解和掌握
Hadoop2.6.0子项目hadoop-mapreduce-examples的简单介绍
热门推荐
beliefer的博客
04-18 1万+
学习Hadoop的同学们，一定知道如果运行Hadoop自带的各种例子。hadoop-mapreduce-examples项目中还提供了这些例子，本文就其中例子的执行方式进行分析。看看它能否让我们学习mapreduce编程变得更加容易。
Hadoop--Hadoop核心之MapReduce
Oner.wv的专栏
10-23 1万+
3 MapReduce     Hadoop的另一个核心是MapReduce。MapReduce是一种分布式计算模型，由Google提出，主要用于搜索领域，解决海量数据的计算问题。     MapReduce由两个阶段组成：Map和Reduce，用户只需要实现map()和reduce()两个函数，即可实现分布式计算，非常简单。这两个函数的形参是key、value对，表示函数的输入信息。 3.
Hadoop-MapReduce调度原理，Yarn原理
qq_40616823的博客
12-28 859
一、MapReduce中的角色 上一节中，我们介绍了MapReduce的一些理论概念。那么mapReduce的框架是如何实现的呢？框架中都分别包含哪些角色呢？ mapReduce框架实现有个目标，就是实现计算向数据移动；其中hdfs集群中已经为我们暴露出了数据块的位置，一个文件块可能会存在多个副本，散列在不同的Datanode中，此时如果客户端要用mapReduce框架计算其中一部分数据，那就有个问题，如何将mapReduce的计算程序“扔”到对应的合适的datanode节点中运行计算呢？在解决这个问题之前
Hadoop 之 MapReduce 工作原理
CodeFlight
09-02 1026
文章目录Hadoop 之 MapReduce 工作原理剖析 MapReduce 作业运行五个核心的实体作业提交（Job Submission）作业初始化（Job Initialization）作业分配（Task Assignment）任务执行（Task Execution）Streaming过程和状态跟新作业完成（Job Completion）失败情况处理（Failures）任务失败（Task Failure）Application Master Failure节点管理器失败（Node Manager Fa
hadoop-MapReduce/Yarn
weixin_63713552的博客
09-05 1186
1.理解MapReduce设计思想2.理解MapReduce分布式计算的基本原理3.掌握使用Java进行MapReduce编程4.掌握在Hadoop集群中提交MapReduce任务1.1 什么是MapReduce1）MapReduce是一个分布式计算框架它将大型数据操作作业分解为可以跨服务器集群并行执行的单个任务。起源于Google2）适用于大规模数据处理场景每个节点处理存储在该节点的数据3）每个job包含Map（分类kv）和Reduce（计算）两部分1.2 MapReduce的设计思想1）分而治之：
大数据-Hadoop（MapReduce）
weixin_59868842的博客
02-05 303
1.MapReduce定义 2.MapReduce优缺点 优点 缺点 3.MapReduce核心思想 1）分布式的运算程序往往需要分成至少2个阶段。 2）第一个阶段的MapTask并发实例，完全并行运行，互不相干。 3）第二个阶段的ReduceTask并发实例互不相干，但是他们的数据依赖于上一个阶段的所有MapTask并发实例的输出。 4）MapReduce编程模型只能包含一个Map阶段和一个Reduce阶段，如果用户的业务逻辑非常复杂，那就只能多个MapRe...
Hadoop框架：MapReduce基本原理和入门案例
m0_57290404的博客
03-06 542
⚫ Hadoop MapReduce是一个分布式计算框架，用于轻松编写分布式应用程序，这些应用程序以可靠，容错的方式并行处理大型硬件集群（数千个节点）上的大量数据（多TB数据集）。⚫ MapReduce是一种面向海量数据处理的一种指导思想，也是一种用于对大规模数据进行分布式计算的编程模型。​。
Hadoop MapReduce原理
07-14
本文分别对传统MapReduce和YARN的体系结构、工作流程及故障处理等三个方面进行讲解，让你深入理解MapReduce的工作原理
Hadoop技术内幕 深入理解MapReduce架构设计与实现原理 高清完整中文版PDF下载
02-27
Hadoop技术内幕 深入理解MapReduce架构设计与实现原理 高清完整中文版PDF下载
Hadoop技术内幕+深入理解MapReduce架构设计与实现原理
01-19
Hadoop技术内幕+深入理解MapReduce架构设计与实现原理Hadoop技术内幕+深入理解MapReduce架构设计与实现原理
Hadoop技术内幕 深入理解MapReduce架构设计与实现原理PDF
01-22
Hadoop技术内幕 深入理解MapReduce架构设计与实现原理pDF，不可用于商业用途，如有版权问题，请联系删除！
Hadoop MapReduce架构
01-07
Hadoop MapReduce 是 Hadoop 平台根据 MapReduce 原理实现的计算框架，目前已经实现了两个版本，MapReduce 1.0 和基于 YARN 结构的 MapReduce 2.0。 尽管 MapReduce 1.0 中存在一些问题，但是整体架构比较清晰，更...
C# WPF入门学习主线篇（十七）—— UniformGrid布局容器
weixin_56595425的博客
06-09 780
在《C# WPF入门学习主线篇（十七）—— UniformGrid布局容器》这篇文章中，我们详细介绍了WPF中的 `UniformGrid` 布局容器。本文涵盖了 `UniformGrid` 的基本概念、常见属性及使用方法，并通过具体的示例代码展示了如何实现均匀排列的网格布局。此外，还讨论了 `UniformGrid` 布局容器的优缺点，帮助读者在实际开发中做出更好的布局选择。
C# WPF入门学习主线篇（十八）—— Border布局容器
weixin_56595425的博客
06-09 538
在《C# WPF入门学习主线篇（十八）—— Border布局容器》这篇文章中，我们详细介绍了WPF中的 `Border` 布局容器。本文涵盖了 `Border` 的基本概念、常见属性及使用方法，并通过具体的示例代码展示了如何使用 `Border` 为控件添加边框和背景。此外，还讨论了 `Border` 布局容器的应用场景，帮助读者在实际开发中更好地美化和组织界面内容。
MapReduce基础编程项目实践
weixin_66158110的博客
06-11 459
在accounts.txt文件中存储如下，第一列为金额大小，第二列表示收入、支出（0表示收入，1表示支出），第三列表示金额出入的月份。我们要通过MapReduce计算每个月过去后的结余，并根据月份大小进行分区，1-3月为1分区，4-6月为2分区，7-9月为3分区，10-12月为4分区。江科大大数据实践项目
java技术专家面试指南80问【java学习+面试宝典】（六）
最新发布
fengbeely的博客
06-15 685
CPU缓存从内存读数据时，是按缓存行读取的，即使只用到一个变量，也要将整行数据进行读取，这行数据量可能包含其他变量。当多个线程同时修改同一个缓存行里的不同变量时，由于同时只能有一个线程在操作，所以相比将每个变量放到不同缓存行里，性能会有所下降。多个线程同时修改了同一个缓存行上的不同变量，由于不能并发修改，所以称为“伪共享”。孤儿卷是未与任何容器关联的卷。在 Docker v。1.9 之前的版本中，删除这些孤儿卷存在很大问题。
谈谈对hadoop技术方法原理的理解
06-07
2. MapReduce原理：MapReduce是Hadoop的核心计算框架，它将任务分成两个阶段：Map和Reduce。在Map阶段，任务被分成多个小任务，然后在不同的节点上并行处理，生成中间结果。在Reduce阶段，中间结果被合并成最终结果...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值