Hadoop基础学习---5、MapReduce概述和WordCount实操(本地运行和集群运行)、Hadoop序列化

简介: Hadoop基础学习---5、MapReduce概述和WordCount实操(本地运行和集群运行)、Hadoop序列化

1、MapReduce概述

1.1 MapReduce定义

MapReduce是一个分布式运算程序的编程框架,是用户开发“基于Hadoop的数据分析应用”的核心框架。

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

1.2 MapReduce的优缺点

1.2.1 优点

1、易于编程

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

2、良好的扩展性

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

3、高容错性

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

4、适合PB级以上海量数据的离线处理

可以实现上千台服务器集群并发工作,提供数据处理能力。

1.2.2 缺点

1、不擅长实时计算

MapReduce 无法像 MySQL 一样,在毫秒或者秒级内返回结果。

2、不擅长流式计算

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

3、不擅长DAG(有向无环图)

多个应用程序存在依赖关系,后一个应用程序的输入为前一个的输出。在这种情况下,MapReduce 并不是不能做,而是使用后,每个 MapReduce 作业的输出结果都会写入到磁盘,会造成大量的磁盘 IO,导致性能非常的低下。

1.3 MapReduce核心思想


fc8168d7fe114b8ea522ff719c55a1cc.png

1、分布式的运算程序往往需要分成至少两个阶段。

2、第一个阶段MapTask并发实例,完全并行运行,互不想干。

3、第二个阶段ReduceTask并发运行,互不相干,但是它们的数据依赖于上一个阶段所以Maptask并发实例的输出。

4、MapReduce编程模型只能包含一个Map阶段和一个Reduce阶段,如果用户的业务逻辑非常复杂,那就只能多个MapReduce程序,串行运行。

1.4 MapReduce进程

一个完整的MapReduce程序在分布式运行时有三类实例进程:

1、MrAppMaster:负责整个程序的过程调度及状态协调。

2、MapTask:负责Map阶段的整个数据处理流程。

3、ReduceTask:负责Reduce阶段的整个数据处理流程。

1.5 常用数据序列化类型

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

1.6 MapReduce 编程规范

用户编写的程序分为三个部分:Mapper、Reducer、Driver

1、Mapper阶段

(1)用户自定义的Mapper要继承自己的父类

(2)Mapper的输入数据是KV对的形式(KV类型可以自定义)

(3)Mapper的业务逻辑写在map()方法中

(4)Mapper的输出数据是KV对的形式(KV类型可自定义)

(5)map()方法(MapTask)对每一个<K,V>调用一次

2、Reducer阶段

(1)用户自定义的Reducer要继承自己的父类

(2)Reducer的输入数据类型对应Mapper的输出数据类型,也是KV

(3)Reducer的业务逻辑写在Reduce()方法中

(4)ReduceTask进程对每一组相同的k的<k,v>组调用一次reduce()方法

3、Driver阶段

相当于Yarn集群的客户端,用于提交我们整个程序到Yarn集群,提交的是封装了MapReduce程序相关运行参数的job对象。

1.7 WordCount案例实操

1.7.1 本地测试

1、需求

在给定的文本文件中统计输出每一个单词出现的总次数

(1)输入数据

59461fc04ff44d95a0ab03b6d2247c89.png

44de7f17499f468bacc20b9a4bcc6e23.png

2、需求分析

按照 MapReduce 编程规范,分别编写 Mapper,Reducer,Driver。

3、环境准备

(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.example.mapreduce.wordcount

4、编写程序

(1)编写Mapper类

package org.example.wordcount;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;
import java.io.IOException;
/**
 * @ClassName WordCountMapper
 * @Description 获取输入数据,将数据以(k,v)输出
 * @Author Zouhuiming
 * @Date 2023/5/19 11:28
 * @Version 1.0
 */
public class WordCountMapper extends Mapper<LongWritable, Text,Text, IntWritable> {
    private  Text text=new Text();
    IntWritable intWritable=new IntWritable(1);
    @Override
    //map是每一行都会运行一次
    protected void map(LongWritable key, Text value, Mapper<LongWritable, Text, Text, IntWritable>.Context context) throws IOException, InterruptedException {
        //获取一行数据
        String line=value.toString();
        //以分隔符生成一个字符串数组
        String[] s = line.split(" ");
        //遍历数组
        for (String s1 : s) {
            text.set(s1);
            context.write(text,intWritable);
        }
    }
}

(2)编写Reducer类

package org.example.wordcount;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;
import java.io.IOException;
/**
 * @ClassName WordCountReduce
 * @Description TODO
 * @Author Zouhuiming
 * @Date 2023/5/19 11:28
 * @Version 1.0
 */
public class WordCountReduce extends Reducer<Text, IntWritable,Text,IntWritable> {
    int sum;
    IntWritable intWritable=new IntWritable();
    @Override
    //每个键值相同的一起reduce
    protected void reduce(Text key, Iterable<IntWritable> values, Reducer<Text, IntWritable, Text, IntWritable>.Context context) throws IOException, InterruptedException {
        sum=0;
        for (IntWritable value : values) {
            sum+=value.get();
        }
        intWritable.set(sum);
        context.write(key,intWritable);
    }
}

(3)编写Driver类

package org.example.wordcount;
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;
import java.io.IOException;
/**
 * @ClassName WordCountDriver
 * @Description TODO
 * @Author Zouhuiming
 * @Date 2023/5/19 11:29
 * @Version 1.0
 */
public class WordCountDriver {
    public static void main(String[] args) throws IOException, InterruptedException, ClassNotFoundException {
        //1、获取job
        Configuration configuration=new Configuration();
        Job job=Job.getInstance(configuration);
        //2、设置jar包路径
        job.setJarByClass(WordCountDriver.class);
        //3、关联mapper和reducer
        job.setMapperClass(WordCountMapper.class);
        job.setReducerClass(WordCountReduce.class);
        //4、设置map输出的kv类型
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(IntWritable.class);
        //5、设置最终输出的kv类型
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(IntWritable.class);
        //6、设置输入路径和输出路径
        FileInputFormat.addInputPath(job,new Path("E:\\testCSDN\\input"));
        FileOutputFormat.setOutputPath(job,new Path("E:\\testCSDN\\output"));
        //7、提交job
        boolean b = job.waitForCompletion(true);
        System.exit(b?0:1);
    }
}

5、本地测试

(1)需要首先配置好 HADOOP_HOME 变量以及 Windows 运行依赖

(2)在 IDEA/Eclipse 上运行程序

6、运行结果

一般出现如下图就运行成功了


319273e7e022457c905bda409d5d68cc.png

92e065a68528485686b60e1f256f9546.png

1.7.2 集群测试

(1)利用maven打jar包,需要添加打包插件依赖

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

注意:如果工程上显示红叉。在项目上右键->maven->Reimport 刷新即可。

(2)将程序打成jar包

5a253b521b52450b931d39580041a460.png

(3)修改不带依赖的 jar 包名称为 wc.jar,并拷贝该 jar 包到 Hadoop 集群的

/opt/module/hadoop-3.1.3 路径。

(4)启动 Hadoop 集群

大家都会启动吧

(5)执行 WordCount 程序

 hadoop jar wc.jar org.example.wordcount.WordCountDriver /user/input /user/output

注意:要提前将单词文件上传到指定集群目录下(本次就是/user/input ),还要保证输出文件目录不存在!!!

2、Hadoop序列化

2.1 序列化概述

1、什么是序列化

序列化就是把内存中的对象,转换成直接序列(或其他数据传输协议)以便储存到磁盘(持久化)和网络传输。

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

2、为什么要进行序列化

一般来说,“活的”对象只生存在内存里,关机断电就没有了。而且“活的”对象只能由本地的进程使用,不能被发送到网络上的另外一台计算机。 然而序列化可以存储“活的”对象,可以将“活的”对象发送到远程计算机。

3、为什么不用java序列化

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

4、Hadoop序列化特点:

(1)紧凑:高效使用储存空间

(2)快速:读写数据的额外开销小

(3)互操作:支持多语言的交互

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

在企业开开发中往往常用的基本序列化类型不能满足所有需求,比如在 Hadoop 框架内部传递一个 bean 对象,那么该对象就需要实现序列化接口。

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

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

2.3 序列化案例实操

1、需求

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

(1)输入数据文件(百度网盘自取数据文件)

链接:https://pan.baidu.com/s/1i2FdQTWFijkrr29n9xAj8Q

提取码:zhm6

(2)输入数据格式

2f9401a1698c4f96a2f7492467ed65d8.png

(3)期望输出数据格式

d2f900753e7940609b3246485c3cc47a.png2、需求分析


b358be250ff54de4b938a0c647cb67eb.png

3、编写MapReduce程序

(1)编写流量统计的 Bean 对象

package org.example.Hadoopxuliehua;
import org.apache.hadoop.io.Writable;
import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
/**
 * @ClassName FlowBean
 * @Description TODO
 * @Author Zouhuiming
 * @Date 2023/5/20 10:13
 * @Version 1.0
 */
public class FlowBean implements Writable {
    private Long  upFlow;
    private Long downFlow;
    private long sumFlow;
    public FlowBean() {
    }
    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 void setSumFlow() {
        this.sumFlow = this.upFlow+this.downFlow;
    }
    //实现序列化
    @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();
    }
    @Override
    public String toString() {
        return upFlow+"\t"+downFlow+"\t"+sumFlow;
    }
}

(2)编写 Mapper 类

package org.example.Hadoopxuliehua;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;
import java.io.IOException;
/**
 * @ClassName FlowMapper
 * @Description TODO
 * @Author Zouhuiming
 * @Date 2023/5/20 10:21
 * @Version 1.0
 */
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, Mapper<LongWritable, Text, Text, FlowBean>.Context context) throws IOException, InterruptedException {
        String[] split = value.toString().split("\t");
        //逐行获取我们需要的用户数据并提取需要的数据
        String phone=split[1];
        String up=split[split.length-3];
        String down=split[split.length-2];
        //封装outK 和outV
        outK.set(phone);
        outV.setUpFlow(Long.parseLong(up));
        outV.setDownFlow(Long.parseLong(down));
        outV.setSumFlow();
        //写出
        context.write(outK,outV);
    }
}

(3)编写 Reducer 类

package org.example.Hadoopxuliehua;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;
import java.io.IOException;
/**
 * @ClassName FlowReducer
 * @Description TODO
 * @Author Zouhuiming
 * @Date 2023/5/20 10:29
 * @Version 1.0
 */
public class FlowReducer extends Reducer <Text,FlowBean,Text,FlowBean>{
    private FlowBean outV=new FlowBean();
    @Override
    protected void reduce(Text key, Iterable<FlowBean> values, Reducer<Text, FlowBean, Text, FlowBean>.Context context) throws IOException, InterruptedException {
        long total_up=0;
        long total_down=0;
        for (FlowBean value : values) {
            total_up+=value.getUpFlow();
            total_down+=value.getDownFlow();
        }
        //封装outKV
        outV.setUpFlow(total_up);
        outV.setDownFlow(total_down);
        outV.setSumFlow();
        //写出
        context.write(key,outV);
    }
}

(4)编写 Driver 驱动类

package org.example.Hadoopxuliehua;
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;
/**
 * @ClassName FlowDriver
 * @Description TODO
 * @Author Zouhuiming
 * @Date 2023/5/20 10:38
 * @Version 1.0
 */
public class FlowDriver {
    public static void main(String[] args) throws IOException, InterruptedException, ClassNotFoundException {
        //1、获取job对象
        Configuration configuration=new Configuration();
        Job job=Job.getInstance(configuration);
        //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.addInputPath(job,new Path("路径写自己的"));
        FileOutputFormat.setOutputPath(job,new Path("路径写自己的"));
        //7、提交Job
        System.exit(job.waitForCompletion(true)?0:1);
    }
}


相关文章
|
22天前
|
分布式计算 Kubernetes Hadoop
大数据-82 Spark 集群模式启动、集群架构、集群管理器 Spark的HelloWorld + Hadoop + HDFS
大数据-82 Spark 集群模式启动、集群架构、集群管理器 Spark的HelloWorld + Hadoop + HDFS
104 6
|
18天前
|
分布式计算 Hadoop 大数据
大数据体系知识学习(一):PySpark和Hadoop环境的搭建与测试
这篇文章是关于大数据体系知识学习的,主要介绍了Apache Spark的基本概念、特点、组件,以及如何安装配置Java、PySpark和Hadoop环境。文章还提供了详细的安装步骤和测试代码,帮助读者搭建和测试大数据环境。
35 1
|
23天前
|
分布式计算 Hadoop Shell
Hadoop-35 HBase 集群配置和启动 3节点云服务器 集群效果测试 Shell测试
Hadoop-35 HBase 集群配置和启动 3节点云服务器 集群效果测试 Shell测试
53 4
|
23天前
|
SQL 分布式计算 Hadoop
Hadoop-37 HBase集群 JavaAPI 操作3台云服务器 POM 实现增删改查调用操作 列族信息 扫描全表
Hadoop-37 HBase集群 JavaAPI 操作3台云服务器 POM 实现增删改查调用操作 列族信息 扫描全表
27 3
|
23天前
|
分布式计算 Hadoop Shell
Hadoop-36 HBase 3节点云服务器集群 HBase Shell 增删改查 全程多图详细 列族 row key value filter
Hadoop-36 HBase 3节点云服务器集群 HBase Shell 增删改查 全程多图详细 列族 row key value filter
50 3
|
23天前
|
分布式计算 Java Hadoop
Hadoop-30 ZooKeeper集群 JavaAPI 客户端 POM Java操作ZK 监听节点 监听数据变化 创建节点 删除节点
Hadoop-30 ZooKeeper集群 JavaAPI 客户端 POM Java操作ZK 监听节点 监听数据变化 创建节点 删除节点
52 1
|
23天前
|
分布式计算 监控 Hadoop
Hadoop-29 ZooKeeper集群 Watcher机制 工作原理 与 ZK基本命令 测试集群效果 3台公网云服务器
Hadoop-29 ZooKeeper集群 Watcher机制 工作原理 与 ZK基本命令 测试集群效果 3台公网云服务器
34 1
|
数据采集 分布式计算 搜索推荐
Hadoop学习---7、OutputFormat数据输出、MapReduce内核源码解析、Join应用、数据清洗、MapReduce开发总结(一)
Hadoop学习---7、OutputFormat数据输出、MapReduce内核源码解析、Join应用、数据清洗、MapReduce开发总结(一)
|
存储 分布式计算 Hadoop
Hadoop基础学习---6、MapReduce框架原理(一)
Hadoop基础学习---6、MapReduce框架原理(一)
|
存储 分布式计算 Hadoop
【Hadoop】一个例子带你了解MapReduce
【Hadoop】一个例子带你了解MapReduce
97 1

热门文章

最新文章