大数据学习总结（2021版）---MapReduce

最新推荐文章于 2023-10-28 09:36:52 发布
最新推荐文章于 2023-10-28 09:36:52 发布
阅读量313 收藏 1
点赞数
分类专栏： 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51755061/article/details/115439062
版权

这里写目录标题

第 1 章 MapReduce 概述

1.1 MapReduce 定义

“分散任务，汇总结果”

1.2 MapReduce 优缺点

优点

  • MapReduce 易于编程
  • 良好的扩展性
  • 高容错性
  • 适合 PB 级以上海量数据的离线处理

缺点

  • 不擅长实时计算
  • 不擅长流式计算
  • 不擅长 DAG（有向无环图）计算

1.3 MapReduce 核心思想

  • 输入（input）—>拆分（Split）:每个文件分片由单独的主机处理，这就是Map方法
  • 各个主机结果汇总，Reduce方法

几个要点：

  • job=Map+Reduce

  • Map的输出是Reduce的输入

  • 所有的输入输出都是<Key, Value>的形式，并且数据类型都是Hadoop的数据类型
    在这里插入图片描述

  • MapReduce要求<Key, Value>的key,value均要实现Writable接口，上面Hadoop的Writable均已实现接口，如需自定义时，记得要实现Wrtable接口

  • MapReduce处理的数据都是HDFS的数据

1.4 MapReduce 编程规范（固定写法）

用户编写的程序分成三个部分：Mapper、Reducer 和 Driver。

1.5 WordCount 案例实操

需求：统计一堆文件中单词出现的个数（WordCount案例）
在这里插入图片描述

1.5.1 环境准备

  • （1）创建 maven 工程，MapReduceDemo
    在这里插入图片描述
  • （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

1.5.2 编写程序

在这里插入图片描述

  • （1）编写 Mapper 类（WordCountMapper）（继承Mapper类，实现自己的Mapper，并重写map（）方法）
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;

/**
 * KEYIN,map阶段输入的key类型：LongWritable
 * VALUEIN,map阶段输入的value类型：Text
 * KEYYOUT,map阶段输出的key类型：Text
 * VALUEOUT,map阶段输出的value类型；IntWritable
 */
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);
        }
    }
}
  • （2）编写 Reducer 类（继承Reducer类，实现自己的Reducer，并重写reduce（）方法）
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;

/**
 * KEYIN,Reduce阶段输入的key类型：Text
 * VALUEIN,Reduce阶段输入的value类型：IntWritable
 * KEYYOUT,Reduce阶段输出的key类型：Text
 * VALUEOUT,Reduce阶段输出的value类型；IntWritable
 */
public class WordCountReducer extends Reducer<Text, IntWritable, Text, IntWritable>{

    int sum;
    IntWritable v = new IntWritable();

    @Override
    //Iterable:类似一个集合
    protected void reduce(Text key, Iterable<IntWritable> values,Context context) throws IOException, InterruptedException {
        // 1 累加求和
        sum = 0;
        for (IntWritable count : values) {
            //因为count是IntWritable类型，sum是int类型，故使用.get()获取
            sum += count.get();
        }
        // 2 输出
        v.set(sum);
        context.write(key,v);//context.write(key,new IntWritable(sum));
    }
}
  • （3）编写 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("D:\\input\\inputword"));
        FileOutputFormat.setOutputPath(job, new Path("D:\\hadoop\\output1"));//注意：输出地址不能已经存在

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

1.5.3 本地测试

在这里插入图片描述

在这里插入图片描述

1.5.4 提交到集群测试

在这里插入图片描述
在这里插入图片描述

  • （1）用 maven 打 jar 包，需要添加的打包插件依赖
    <build>
        <plugins>
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.6.1</version>
                <configuration>
                    <source>11</source>
                    <target>11</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）将程序打成 jar 包，并打开
    在这里插入图片描述
    在这里插入图片描述

  • （3）显示打包的jar包
    在这里插入图片描述
    注意：一般常用不带依赖的

  • （4）修改不带依赖的 jar 包名称为 wc.jar，并拷贝该 jar 包到 Hadoop 集群的
    /opt/module/hadoop-3.1.3 路径，
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

  • （4）启动 Hadoop 集群

  • （5）执行 WordCount 程序
    在这里插入图片描述
    启动：

在这里插入图片描述
成功：
在这里插入图片描述

第 2 章 Hadoop 序列化

2.1 Hadoop 序列化特点

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

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

具体实现 bean 对象序列化步骤如下 7 步

  • （1）必须实现 Writable 接口
  • （2）反序列化时，需要反射调用空参构造函数，所以必须有空参构造
  • （3）重写序列化方法
  • （4）重写反序列化方法
  • （5）注意反序列化的顺序和序列化的顺序完全一致
  • （6）要想把结果显示在文件中，需要重写 toString()，可用"\t"分开，方便后续用。
  • （7）如果需要将自定义的 bean 放在 key 中传输，则还需要实现 Comparable 接口，因为
    MapReduce 框中的 Shuffle 过程要求对 key 必须能排序。详见后面排序案例。
@Override
public int compareTo(FlowBean o) {
// 倒序排列，从大到小
return this.sumFlow > o.getSumFlow() ? -1 : 1;
}

2.3 序列化案例实操

统计每一个手机号耗费的总上行流量、总下行流量、总流量
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

统计结果
在这里插入图片描述

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

package com.atguigu.mapreduce.writable;

import org.apache.hadoop.io.Writable;

import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;

/**
 * @author shkstart
 * @create 2021-04-07 11:15
 */

//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 long getDownFlow() {
        return downFlow;
    }

    public long getSumFlow(){
        return getSumFlow();
    }

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

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

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

    //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 类

package com.atguigu.mapreduce.writable;


import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

import java.io.IOException;

/**
 * @author shkstart
 * @create 2021-04-07 11:25
 */
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();

        context.write(outk,outv);
    }
}

（3）编写 Reducer 类

package com.atguigu.mapreduce.writable;

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

import java.io.IOException;

/**
 * @author shkstart
 * @create 2021-04-07 14:53
 */
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 驱动类

package com.atguigu.mapreduce.writable;


import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
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;

import java.awt.*;
import java.io.IOException;

/**
 * @author shkstart
 * @create 2021-04-07 15:03
 */
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端输出LV类型
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(FlowBean.class);

        //5 设置程序最终输出的KV类型
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(FlowBean.class);

        //6 设置程序的输入输出路径
        FileInputFormat.setInputPaths(job, new Path("C:\\Users\\Administrator\\Desktop\\phone_data.txt"));
        FileOutputFormat.setOutputPath(job,new Path("C:\\Users\\Administrator\\Desktop\\jar1"));

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




    }
}

注意：活用deBug

第 3 章 MapReduce 框架原理

在这里插入图片描述

3.1 InputFormat 数据输入

3.1.1 切片与 MapTask 并行度决定机制

  • 1）一个Job的Map阶段并行度由客户端在提交Job时的切片数决定
  • 2）每一个Split切片分配一个MapTask并行实例处理
  • 3）默认情况下，切片大小=BlockSize
  • 4）切片时不考虑数据集整体，而是逐个针对每一个文件单独切片

3.1.2 FileInputFormat 切片源码解析和切片机制（input.getSplits(job)）

在这里插入图片描述

在这里插入图片描述

3.1.4 FileInputFormat 实现类—TextInputFormat

  • 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)

3.1.5 FileInputFormat 实现类—CombineTextInputFormat

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

3.1.6 CombineTextInputFormat 案例实操

1：需求

在这里插入图片描述

2：实现过程
（1）不做任何处理，运行 1.8 节的 WordCount 案例程序，观察切片个数为 4。
在这里插入图片描述
在这里插入图片描述
（2）在 WordcountDriver 中增加如下代码，运行程序，并观察运行的切片个数
（a）驱动类中添加代码如下：

// 如果不设置 InputFormat，它默认用的是 TextInputFormat.class
job.setInputFormatClass(CombineTextInputFormat.class);
//虚拟存储切片最大值设置 4m
CombineTextInputFormat.setMaxInputSplitSize(job, 4194304);

在这里插入图片描述
（b）运行结果为 1个切片。
在这里插入图片描述

3.2 MapReduce 工作流程

3.3 Shuffle 机制（面试重点）

3.3.1 Shuffle 机制

Map 方法之后，Reduce 方法之前的数据处理过程称之为 Shuffle。
在这里插入图片描述

在这里插入图片描述

3.3.2 Partition 分区

  • 1、默认Partitioner分区

默认分区是根据key的hashCode对ReduceTasks个数取模得到的。用户没法控制哪个key存储到哪个分区。

举例1：原始数据
在这里插入图片描述
举例1：设置生成两个文件
在这里插入图片描述
举例1：结果：

在这里插入图片描述

源码解析（debug）（设置为2，处理流程）
在这里插入图片描述
在这里插入图片描述

源码解析（debug）（不设置为2处理流程，默认为1个分区）

在这里插入图片描述
在这里插入图片描述
只会产生一个0号文件

  • 3、自定义Partitioner步骤
    在这里插入图片描述
  • 4、分区总结
    在这里插入图片描述
    结论：如果不设置ReduceTask,其默认值为1，不会进入hashpartitioner方法。就只会生成一个文件
    设置ReduceTask后，如果其值大于自定义分区数（partition的值），程序会正常运行，不过会产生空文件
    设置ReduceTask后，如果其值小于自定义分区数（partition的值），程序会报错
  • 5、案例分析
    在这里插入图片描述

3.3.3 Partition 分区案例实操

在这里插入图片描述

在前面案例writable案例的基础上，增加一个分区类

package com.atguigu.mapreduce.partitioner2;

import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Partitioner;

/**
 * @author shkstart
 * @create 2021-04-08 17:05
 */
public class ProvincePartitioner extends Partitioner<Text,FlowBean> {
    @Override
    public int getPartition(Text text, FlowBean flowBean, int i) {//text是手机号
        //获取手机号前三位
        String phone = text.toString();
        String prePhone = phone.substring(0,3);

        //定义一个分区号变量partition,根据prePhone设置分区号

        int partition;
        if("136".equals(prePhone)){
            //设置该136开头的手机号放入分区号为0的文件
            partition = 0;
        }else if("137".equals(prePhone)){
            //设置137开头的手机号放入分区号为1的文件
            partition = 1;
        }else if("138".equals(prePhone)){
            partition = 2;
        }else if("139".equals(prePhone)){
            partition = 3;
        }else {
            partition = 4;
        }
        //最后返回分区号
        return partition;
    }
}

在驱动函数中增加自定义数据分区设置和 ReduceTask 设置

//8 指定自定义分区器
 job.setPartitionerClass(ProvincePartitioner.class);
 
//9 同时指定相应数量的 ReduceTask
 job.setNumReduceTasks(5);

在这里插入图片描述

结果：
在这里插入图片描述

3.3.4 WritableComparable 排序

  • MapTask和ReduceTask均会对数据按照key进行排序
  • 任何应用程序中的数据均会被排序，而不管逻辑上是
    否需要
  • 默认排序是按照字典顺序排序，且实现该排序的方法是快速排序。
  • 排序分类：部分排序、全排序、辅助排序、二次排序

自定义排序 WritableComparable 原理分析
实现 WritableComparable 接口重写 compareTo 方法，就可以实现排序。

@Override
public int compareTo(FlowBean bean) {
	return 0;
 }

3.3.5 WritableComparable 排序案例实操（全排序）

在这里插入图片描述

代码实现

（1）FlowBean 对象在在需求 1 基础上增加了比较功能

  • 注意点1：实现的是WritableComparable接口
  • 注意点2：重写了compareTo方法

:

package com.atguigu.mapreduce.writableComparable;


import org.apache.hadoop.io.WritableComparable;

import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;

/**
 * @author shkstart
 * @create 2021-04-07 11:15
 */

//1 继承 Writable 接口
public class FlowBean  implements WritableComparable<FlowBean> {
    private long upFlow;//上行流量
    private long downFlow; //下行流量
    private long sumFlow;//总流量

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

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

    public long getDownFlow() {
        return downFlow;
    }

    public long getSumFlow(){
        return getSumFlow();
    }

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

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

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

    //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;
    }

    //排序比较
    @Override
    public int compareTo(FlowBean o){

        //按照总流量排序
        if(this.sumFlow > o.sumFlow){
            return -1;
        }else if(this.sumFlow < o.sumFlow){
            return  1;
        }else{
            return  0;
        }
    }
}

（2）编写 Mapper 类

  • 注意点1：输入k,v类型：LongWritable,Text
  • 注意点2：输出k,v类型：FlowBean,Text
package com.atguigu.mapreduce.writableComparable;


import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

import java.io.IOException;

/**
 * @author shkstart
 * @create 2021-04-07 11:25
 */
public class FlowMapper extends Mapper<LongWritable,Text,FlowBean,Text>{
    FlowBean outk = new FlowBean();
    Text outv = new Text();

    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        //1.获取一行数据
        String line = value.toString();

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

        //3 封装outk outv
        outk.setUpFlow(Long.parseLong(split[1]));
        outk.setDownFlow(Long.parseLong(split[2]));
        outk.setSumFlow();
        outv.set(split[0]);

        //4 写出outK outV
        context.write(outk,outv);
    }


}

（3）编写 Reducer 类

  • 注意点1：输入输出k,v类型FlowBean, Text,Text, FlowBean
package com.atguigu.mapreduce.writableComparable;

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

import java.io.IOException;

/**
 * @author shkstart
 * @create 2021-04-07 14:53
 */
public class FlowReducer extends Reducer<FlowBean, Text,Text, FlowBean> {


    @Override
    protected void reduce(FlowBean key, Iterable<Text> values, Context context) throws IOException, InterruptedException {

        //遍历value集合，循环写出，避免总流量相同的情况
        for(Text value : values){
            //调换kv的位置，反向写出
            context.write(value,key);
        }
    }
}

（4）编写 Driver 类

package com.atguigu.mapreduce.writableComparable;


import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
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;

import java.io.IOException;

/**
 * @author shkstart
 * @create 2021-04-07 15:03
 */
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端输出LV类型
        job.setMapOutputKeyClass(FlowBean.class);
        job.setMapOutputValueClass(Text.class);

        //5 设置程序最终输出的KV类型
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(FlowBean.class);

        //6 设置程序的输入输出路径
        FileInputFormat.setInputPaths(job, new Path("C:\\Users\\Administrator\\Desktop\\jar1"));
        FileOutputFormat.setOutputPath(job,new Path("C:\\Users\\Administrator\\Desktop\\jar2"));

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

    }
}

结果
在这里插入图片描述

3.3.6 WritableComparable 排序案例实操（区内排序）

在这里插入图片描述

在这里插入图片描述

3：案例实操

（1）增加自定义分区类ProvincePartitioner2

package com.atguigu.mapreduce.partitionerandwritableComparable;


import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Partitioner;


/**
 * @author shkstart
 * @create 2021-04-08 17:05
 */
public class ProvincePartitioner2 extends Partitioner<FlowBean,Text> {
    @Override
    public int getPartition(FlowBean flowBean,Text text ,int numPartitions) {//text是手机号
        //获取手机号前三位
        String phone = text.toString();
        String prePhone = phone.substring(0,3);

        //定义一个分区号变量partition,根据prePhone设置分区号

        int partition;
        if("136".equals(prePhone)){
            //设置该136开头的手机号放入分区号为0的文件
            partition = 0;
        }else if("137".equals(prePhone)){
            //设置137开头的手机号放入分区号为1的文件
            partition = 1;
        }else if("138".equals(prePhone)){
            partition = 2;
        }else if("139".equals(prePhone)){
            partition = 3;
        }else {
            partition = 4;
        }
        //最后返回分区号
        return partition;
    }


}

（2）在驱动类FlowDriver中添加分区类

        //指定自定义分区器
        job.setPartitionerClass(ProvincePartitioner2.class);

        //设置对应的ReduceTask
        job.setNumReduceTasks(5);


package com.atguigu.mapreduce.partitionerandwritableComparable;


import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
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;

import java.io.IOException;

/**
 * @author shkstart
 * @create 2021-04-07 15:03
 */
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端输出LV类型
        job.setMapOutputKeyClass(FlowBean.class);
        job.setMapOutputValueClass(Text.class);

        //5 设置程序最终输出的KV类型
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(FlowBean.class);

        //指定自定义分区器
        job.setPartitionerClass(ProvincePartitioner2.class);

        //设置对应的ReduceTask
        job.setNumReduceTasks(5);

        //6 设置程序的输入输出路径
        FileInputFormat.setInputPaths(job, new Path("C:\\Users\\Administrator\\Desktop\\jar1"));
        FileOutputFormat.setOutputPath(job,new Path("C:\\Users\\Administrator\\Desktop\\jar9"));

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


    }
}

FlowBean类

package com.atguigu.mapreduce.partitionerandwritableComparable;


import org.apache.hadoop.io.WritableComparable;
import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;

/**
 * @author shkstart
 * @create 2021-04-07 11:15
 */

//1 继承 Writable 接口
public class FlowBean  implements WritableComparable<FlowBean> {
    private long upFlow;//上行流量
    private long downFlow; //下行流量
    private long sumFlow;//总流量

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

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

    public long getDownFlow() {
        return downFlow;
    }

    public long getSumFlow(){
        return getSumFlow();
    }

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

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

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

    //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;
    }

    //排序比较
    @Override
    public int compareTo(FlowBean o){

        //按照总流量排序
        if(this.sumFlow > o.sumFlow){
            return -1;
        }else if(this.sumFlow < o.sumFlow){
            return  1;
        }else{
            return  0;
        }
    }
}

FlowMapper类

package com.atguigu.mapreduce.partitionerandwritableComparable;


import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

import java.io.IOException;

/**
 * @author shkstart
 * @create 2021-04-07 11:25
 */
public class FlowMapper extends Mapper<LongWritable,Text, FlowBean,Text>{
    FlowBean outk = new FlowBean();
    Text outv = new Text();

    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        //1.获取一行数据
        String line = value.toString();

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

        //3 封装outk outv
        outk.setUpFlow(Long.parseLong(split[1]));
        outk.setDownFlow(Long.parseLong(split[2]));
        outk.setSumFlow();
        outv.set(split[0]);

        //4 写出outK outV
        context.write(outk,outv);
    }
    
}

FlowReducer类

package com.atguigu.mapreduce.partitionerandwritableComparable;

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

import java.io.IOException;

/**
 * @author shkstart
 * @create 2021-04-07 14:53
 */
public class FlowReducer extends Reducer<FlowBean, Text,Text, FlowBean> {


    @Override
    protected void reduce(FlowBean key, Iterable<Text> values, Context context) throws IOException, InterruptedException {

        //遍历value集合，循环写出，避免总流量相同的情况
        for(Text value : values){
            //调换kv的位置，反向写出
            context.write(value,key);
        }
    }
}

结果：在这里插入图片描述

3.3.7 Combiner 合并

将 WordcountReducer 作为 Combiner 在 WordcountDriver 驱动类中指定

// 指定需要使用 Combiner，以及用哪个类作为 Combiner 的逻辑
job.setCombinerClass(WordCountReducer.class);

在这里插入图片描述

3.4 OutputFormat 数据输出

3.4.1 OutputFormat 接口实现类

3.4.2 自定义 OutputFormat 案例实操

3.5 MapReduce 内核源码解析

3.5.1 MapTask 工作机制

在这里插入图片描述
五大阶段！！！！！！！

3.5.2 ReduceTask 工作机制

在这里插入图片描述
三大阶段！！！！！！！

3.5.3 ReduceTask 并行度决定机制

  • MapTask 并行度由切片个数决定，切片个数由输入文件和切片规则决定
  • ReduceTask 的并行度数量的决定是可以直接手动设置，默认为1
// 默认值是 1，手动设置为 4
job.setNumReduceTasks(4);

一般情况下，在企业里面ReduceTask 的并行度数量需要进行测试后得出！！！

3.5.4 MapTask & ReduceTask 源码解析

  • MapTask 源码解析流程
    在这里插入图片描述
    举例：

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

  • ReduceTask 源码解析流程

3.6 Join 应用

3.6.1 Reduce Join

3.6.2 Reduce Join 案例实操

3.6.3 Map Join

3.6.4 Map Join 案例实操

3.7 数据清洗（ETL）

3.8 MapReduce 开发总结

在这里插入图片描述

第 4 章 Hadoop 数据压缩

4.1 压缩算法对比介绍

在这里插入图片描述
在这里插入图片描述

4.2 压缩性能的比较

在这里插入图片描述

4.3 压缩位置选择

在这里插入图片描述

4.4 压缩实操案例

4.4.1 Map 输出端采用压缩

在这里插入图片描述

4.4.2 Reduce 输出端采用压缩

在这里插入图片描述

亿钱君
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
大数据基本要素HDFS MapReduce-and-Spark-RDD
02-12
总结，HDFS、MapReduce和Spark RDD是大数据处理的基石，它们共同构建了大数据生态系统，使得我们能够高效地存储、处理和分析海量数据。理解这些概念和技术对于从事大数据工作的专业人士至关重要，也是推动企业从数据...
大数据电商项目-Hadoop-Website-Project.zip
最新发布
11-04
总结，这个项目旨在利用Hadoop处理电商网站产生的大数据，通过一系列数据分析手段提升业务运营效率和用户体验。通过深入研究此项目，可以学习到Hadoop生态系统在实际项目中的应用，以及如何解决电商领域的大数据挑战...
MapReduce【数据压缩】
梦想是动物管理员
05-29 881
Hadoop数据压缩
大数据：脚本实现WordCount，结果以压缩格式输出到HDFS
博樽
07-04 321
脚本实现WordCount，词频统计结果以压缩格式输出到HDFS，然后对HDFS的压缩文件再用脚本解压。
MapReduce编写wordcount程序
m0_63716485的博客
10-30 1245
新手上路，MapReduce编写wordcount程序，包含了一些遇到的问题的解决办法。
hadoop入门 使用MapReduce编写 WordCount程序（一）
weixin_43205308的博客
03-31 589
org.apache.hadoop.io.nativeio.NativeIOException: 当文件已存在时，无法创建该文件”3、以管理员身份运行你的ide(我适应的是idea),如果在配置环境变量前已经打开，关闭再重新打开。5、编写Mapper。6、编写reduce。
Word Count案例完成过程
A157190的博客
05-18 452
Word Count案例完成过程
北航大数据部分-新.pptx
04-19
大数据技术的发展历程和...总结来说，大数据技术的发展是从基础架构到高级应用的演进，不断适应并解决新的挑战，如数据类型、处理速度和分析复杂性。未来，大数据将继续与AI和云计算深度融合，为企业创造更大的价值。
大数据技术基础实验报告-Hive安装配置与应用.doc
08-21
【大数据技术基础实验报告-Hive安装配置与应用】 在大数据处理领域，Apache Hive是一个非常重要的组件，它提供了基于Hadoop的数据仓库工具，用于数据查询、分析以及存储。本实验报告将详细阐述如何安装、配置Hive，...
java代码-大数据 02 实训4-4
07-15
总结来说，这个Java大数据实训项目涵盖了大数据处理的全生命周期，从数据的获取、存储、处理到分析和展示，都是Java开发者需要掌握的关键技能。通过实践，你可以提升在大数据环境下的编程能力，并了解如何利用Java...
Hadoop中Partition深度解析
02-26
Partitioner的作用是对Mapper产生的中间结果进行分片，以便将同一分组的数据交给同一个Reducer处理，它直接影响Reduce阶段的负载均衡。旧版API中Partitioner的类图如图所示。它继承了JobConfigurable，可通过configure方法初始化。它本身只包含一个待实现的方法getPartition。该方法包含三个参数，均由框架自动传入，前面两个参数是key/value，第三个参数numPartitions表示每个Mapper的分片数，也就是Reducer的个数。MapReduce提供了两个Partitioner实现：HashPartitioner和Total
MapReduce WordCount案例分析以及代码实现
zzq的博客
03-12 2781
环境参数：hadoop3.2.1、IDEA、maven3.6 案例分析 WordCount程序是学习Hadoop的入门程序，我们有必要详解一下。能够完整的运行WordCount程序需要如下步骤：本地的文本文件上传到HDFS上，WordCount程序实现MapReduce过程，输出结果到HDFS上。 首先来看一下WordCount简化的MapReduce工作过程(这个过程简化了许多)： ...
Hadoop学习——Partition分区
HadwinLing
11-21 882
要求：将统计的结果按照条件输出到不同文件中（分区）。比如：将统计结果按照收集归属地不同省份输出到不同文件中（分区） 默认Partition分区 默认分区是根据key的hashcode对ReduceTasks个数取模得到的，用户无法控制哪个key存储到哪个分区 可以在驱动类中编写如下进行分区操作 job.setNumReduceTasks(5);//设置几个分区 自定义分区 步骤： 1. 自定义类继承Partitioner ,重写getPartition()方法 public class ProvinceP
Hadoop中Partition解析
weixin_33817333的博客
10-27 197
1.解析Partition Map的结果，会通过partition分发到Reducer上，Reducer做完Reduce操作后，通过OutputFormat，进行输出，下面我们就来分析参与这个过程的类。 Mapper的结果，可能送到Combiner做合并，Combiner在系统中并没有自己的基类，而是用Reducer作为Combiner的基类，他们对外的功能是一样的，只是使用的位置和使用时的上...
MapReduce实战之WordCount案例
Faded1573606285的博客
09-09 510
WordCount案例 1.1 需求1：统计一堆文件中单词出现的个数 0）需求：在一堆给定的文本文件中统计输出每一个单词出现的总次数 1）数据准备： hello world atguigu atguigu hadoop spark hello world atguigu atguigu hadoop spark hello world atguigu atguigu hadoop s...
Hadoop Partition函数应用(归档)
04-13 536
得到map产生的记录后，他们该分配给哪些reducer来处理呢？hadoop默认是根据散列值来派发，但是实际中，这并不能很高效或者按照我们要求的去执行任务。例如，经过partition处理后，一个节点的reducer分配到了20条记录，另一个却分配到了10W万条，试想，这种情况效率如何。
【大数据之Hadoop】十二、MapReduce之Partition分区
阿宁的博客
04-11 254
（3）如果ReduceTask的数量==1，则不管MapTask端输出多少分区文件，最终结果都交给一个 ReduceTask，即使用默认分区，只产生一个结果文件。（2）如果 1 < ReduceTask的数量 < getPartition的结果数，则有部分分区数据无处存储，会抛出IO异常。（3）自定义Partition后，根据自定义的逻辑设置相应数量的ReduceTask。不设置时默认为1，则使用默认分区。（1）如果ReduceTask的数量 > getPartition的结果数，则会多产生几个空文件。
Hadoop中MapReduce阶段中，Patition分区、ReduceTask、输出文件之间的关系
m0_52445307的博客
10-28 422
该整数就是键（key）所对应的分区号，使得键（key）被映射到介于 0 到 numReduceTasks - 1 之间的分区，numReduceTasks 表示 Reduce 任务的总数，从而确定了键所属的分区。（4）、若ReduceTasks数 = 1，则不管有MapTask端输出多少个分区文件，最终结果都会交给这一个ReduceTask处理，所以也只会产生一个结果文件part-r-00000。的数量是一一对应的，但分区数与输出文件的个数之间没有直接的关系。）进行分区，不同的键会被分配到不同的分区中。
大数据培训课程WordCount案例实操
zjjcchina的博客
12-02 423
（1）如果电脑系统是win7的就将win7的hadoop jar包解压到非中文路径，并在Windows环境上配置HADOOP_HOME环境变量。com.atguigu.mr.WordcountDriver /user/atguigu/input /user/atguigu/output 注意：com.atguigu.mr.WordcountDriver要和自己工程的全类名一致。（2）在项目的src/main/resources目录下，新建一个文件，命名为“log4j.properties”，在文件中填入。
大数据基础-走进大数据-第一章-数据时代--从我开始.ppt
12-24
大数据基础-走进大数据-第一章-数据...通过阅读和学习这份文档，我们可以更好地理解和应用大数据的知识和技术，为我们的工作和生活带来更多的价值。如果有任何问题，我们可以第一时间联系作者，获取更多的帮助和指导。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值