【大数据day13】——MapReduce提升（MapReduce 排序和序列化，规约Combiner，MapReduce案例-流量统计,统计求和,上行流量倒序排序（递减排序）,手机号码分区）

其他 2021-03-31 15:34:10 阅读次数: 0

Hadoop-Mapreduce

文章目录

代码及资料：
链接：https://pan.baidu.com/s/1HQxgbi6hZk0yLXnamm0Ftg
提取码：ei8o
复制这段内容后打开百度网盘手机App，操作更方便哦

接上一篇博客

7 MapReduce 排序和序列化

  • 序列化 (Serialization) 是指把结构化对象转化为字节流
  • 反序列化 (Deserialization) 是序列化的逆过程. 把字节流转为结构化对象. 当要在进程间传递对象或持久化对象的时候, 就需要序列化对象成字节流, 反之当要将接收到或从磁盘读取的字节流转换为对象, 就要进行反序列化
  • Java 的序列化 (Serializable) 是一个重量级序列化框架, 一个对象被序列化后, 会附带很多额外的信息 (各种校验信息, header, 继承体系等）, 不便于在网络中高效传输. 所以, Hadoop 自己开发了一套序列化机制(Writable), 精简高效. 不用像 Java 对象类一样传输多层的父子关系, 需要哪个属性就传输哪个属性值, 大大的减少网络传输的开销
  • Writable 是 Hadoop 的序列化格式, Hadoop 定义了这样一个 Writable 接口. 一个类要支持可序列化只需实现这个接口即可
  • 另外 Writable 有一个子接口是 WritableComparable, WritableComparable 是既可实现序列化, 也可以对key进行比较, 我们这里可以通过自定义 Key 实现 WritableComparable 来实现我们的排序功能

数据格式如下

a	1
a	9
b	3
a	7
b	8
b	10
a	5

要求:

  • 第一列按照字典顺序进行排列
  • 第一列相同的时候, 第二列按照升序进行排列

解决思路:

  • 将 Map 端输出的 <key,value> 中的 key 和 value 组合成一个新的 key (newKey), value值不变
  • 这里就变成 <(key,value),value>, 在针对 newKey 排序的时候, 如果 key 相同, 就再对value进行排序

在这里插入图片描述

Step 1. 自定义类型和比较器
package cn.wbslz.mapreduce.sort;

import org.apache.hadoop.io.WritableComparable;

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

public class SortBean implements WritableComparable<SortBean> {
    
    

    private String word;
    private int num;

    public String getWord() {
    
    
        return word;
    }

    public void setWord(String word) {
    
    
        this.word = word;
    }

    public int getNum() {
    
    
        return num;
    }

    public void setNum(int num) {
    
    
        this.num = num;
    }

    //实现比较器，指定排序规则
    /*
    规则：
        - 第一列（word）按照字典顺序进行排列 //26个单词顺序 如： aac  abc abd
        - 第一列相同的时候, 第二列(num)按照升序进行排列
     */
    @Override
    public int compareTo(SortBean sortBean) {
    
    
        //将前单词与传入单词比较
        //先对第一列排序word顺序
        int result = this.word.compareTo(sortBean.word);
        /*
        result>0： 表示当前单词比传入单词大
        result=0：表示当前单词与传入单词相同
        result<0：表示当前单词比传入单词小
         */
        //如果第一列相同，则按照第二列进行排序
        if(result==0){
    
    
            return this.num - sortBean.num;
        }

        return result;
    }

    //实现序列化
    @Override
    public void write(DataOutput dataOutput) throws IOException {
    
    
        dataOutput.writeUTF(word);//字符串默认调用
        dataOutput.writeInt(num);

    }
    //反序列化
    @Override
    public void readFields(DataInput dataInput) throws IOException {
    
    
        this.word = dataInput.readUTF();
        this.num = dataInput.readInt();
    }

    @Override
    public String toString() {
    
    
        return  word + "\t" + num;
    }
}
Step 2. Mapper
package cn.wbslz.mapreduce.sort;

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

import java.io.IOException;

public class SortMapper extends Mapper<LongWritable, Text, SortBean, NullWritable> {
    
    
    /**
     * map方法将k1,v1转为k2,v2
     *    k1         v1
     *    0          a 3
     *    5          b 7
     *    ===============
     *    k2                v2
     *    SortBean(a 3)      NullWriteble
     *    SortBean(b 7)      NullWriteble
     *
     * @param key
     * @param value
     * @param context
     * @throws IOException
     * @throws InterruptedException
     */
    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
    
    
        //1.将行文本数据（v1）拆分，并将数据封装到SortBean中，就可以得到v2
        String[] split = value.toString().split("\t");

        SortBean sortBean = new SortBean();
        sortBean.setWord(split[0]);
        sortBean.setNum(Integer.parseInt(split[1]));

        //2.将k2,v2写入上下文中
        context.write(sortBean,NullWritable.get());
    }
}
Step 3.Reducer
package cn.wbslz.mapreduce.sort;

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

import java.io.IOException;

public class SortReducer extends Reducer<SortBean, NullWritable,SortBean,NullWritable> {
    
    

    /**
     * 将新的k2,v2转为k3,v3
     * @param key
     * @param values
     * @param context
     * @throws IOException
     * @throws InterruptedException
     */
    @Override
    protected void reduce(SortBean key, Iterable<NullWritable> values, Context context) throws IOException, InterruptedException {
    
    
        context.write(key,NullWritable.get());
    }
}
Step 4. Main 入口
package cn.wbslz.mapreduce.sort;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.conf.Configured;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;
import org.apache.hadoop.util.Tool;
import org.apache.hadoop.util.ToolRunner;

public class JobMain extends Configured implements Tool {
    
    

    @Override
    public int run(String[] strings) throws Exception {
    
    
        //1.创建job对象
        Job job = Job.getInstance(super.getConf(), "mapreduce_sort");
        //2.配置job任务（八个步骤）
            //第一步：设置输入类和输入路径
            job.setInputFormatClass(TextInputFormat.class);
            //虚拟机运行输入路径
            //TextInputFormat.addInputPath(job, new Path("hdfs://node01:8020/input/sort_input"));
            //本地运行输入路径配置
            TextInputFormat.addInputPath(job, new Path("file:///D:\\IdeaWorkSpace\\bigDate\\data\\sort\\sort_input\\*"));
            //第二步：设置Mapper类和数据类型
            job.setMapperClass(SortMapper.class);
            job.setMapOutputKeyClass(SortBean.class);
            job.setMapOutputValueClass(NullWritable.class);

            //第三，四，五，六 使用默认配置

            //第七步：设置reducer类和类型
            job.setReducerClass(SortReducer.class);
            job.setOutputKeyClass(SortBean.class);
            job.setOutputValueClass(NullWritable.class);

            //第八步：设置输出类型和输出路径
            job.setOutputFormatClass(TextOutputFormat.class);
            //虚拟机运行输出路径配置
            //TextOutputFormat.setOutputPath(job,new Path("hdfs://node01:8020/out/sort_out"));
            //本地运行输出路径配置
            TextOutputFormat.setOutputPath(job,new Path("file:///D:\\IdeaWorkSpace\\bigDate\\data\\sort\\sort_output"));

        //3:等待任务结束
        boolean bl = job.waitForCompletion(true);

        return bl ? 0:1;
    }

    public static void main(String[] args) throws Exception {
    
    
        Configuration configuration = new Configuration();
        //启动job任务
        int run = ToolRunner.run(configuration, new JobMain(), args);

        System.exit(run);
    }
}
Step 5.运行
Linux环境下运行
  1. 将程序打包
    在这里插入图片描述
  2. 将原文件与打包好的程序上传到node01中
    在这里插入图片描述
  3. 将sort.txt文件上传到input/sort_input目录

在这里插入图片描述

  1. 执行命令
hadoop jar original-day06_mapreduce-1.0-SNAPSHOT.jar cn.wbslz.mapreduce.sort.JobMain
  1. 运行结果：

在这里插入图片描述

本地运行
  1. 在本地创建输入目录并原文件放入
    在这里插入图片描述
  2. 修改代码地址（程序中已有）
  3. 运行main函数
  4. 运行结果
    在这里插入图片描述

8 规约Combiner

概念

每一个 map 都可能会产生大量的本地输出，Combiner 的作用就是对 map 端的输出先做一次合并，以减少在 map 和 reduce 节点之间的数据传输量，以提高网络IO 性能，是 MapReduce 的一种优化手段之一

  • combiner 是 MR 程序中 Mapper 和 Reducer 之外的一种组件
  • combiner 组件的父类就是 Reducer
  • combiner 和 reducer 的区别在于运行的位置
    • Combiner 是在每一个 maptask 所在的节点运行
    • Reducer 是接收全局所有 Mapper 的输出结果
  • combiner 的意义就是对每一个 maptask 的输出进行局部汇总，以减小网络传输量
    在这里插入图片描述wordCount案例无combiner
    在这里插入图片描述

在这里插入图片描述wordCount案例有combiner
在这里插入图片描述

实现步骤
  1. 自定义一个 combiner 继承 Reducer，重写 reduce 方法
  2. 在 job 中设置 job.setCombinerClass(CustomCombiner.class)

combiner 能够应用的前提是不能影响最终的业务逻辑，而且，combiner 的输出 kv 应该跟 reducer 的输入 kv 类型要对应起来

9 MapReduce案例-流量统计

数据：
在这里插入图片描述在这里插入图片描述

需求一: 统计求和

统计每个手机号的上行数据包总和，下行数据包总和，上行总流量之和，下行总流量之和
分析：以手机号码作为key值，上行流量，下行流量，上行总流量，下行总流量四个字段作为value值，然后以这个key，和value作为map阶段的输出，reduce阶段的输入

分析：

在这里插入图片描述

Step 1: 自定义map的输出value对象FlowBean
public class FlowBean implements Writable {
    
    
    private Integer upFlow;
    private Integer  downFlow;
    private Integer upCountFlow;
    private Integer downCountFlow;
    @Override
    public void write(DataOutput out) throws IOException {
    
    
        out.writeInt(upFlow);
        out.writeInt(downFlow);
        out.writeInt(upCountFlow);
        out.writeInt(downCountFlow);
    }
    @Override
    public void readFields(DataInput in) throws IOException {
    
    
        this.upFlow = in.readInt();
        this.downFlow = in.readInt();
        this.upCountFlow = in.readInt();
        this.downCountFlow = in.readInt();
    }
    public FlowBean() {
    
    
    }
    public FlowBean(Integer upFlow, Integer downFlow, Integer upCountFlow, Integer downCountFlow) {
    
    
        this.upFlow = upFlow;
        this.downFlow = downFlow;
        this.upCountFlow = upCountFlow;
        this.downCountFlow = downCountFlow;
    }
    public Integer getUpFlow() {
    
    
        return upFlow;
    }
    public void setUpFlow(Integer upFlow) {
    
    
        this.upFlow = upFlow;
    }
    public Integer getDownFlow() {
    
    
        return downFlow;
    }
    public void setDownFlow(Integer downFlow) {
    
    
        this.downFlow = downFlow;
    }
    public Integer getUpCountFlow() {
    
    
        return upCountFlow;
    }
    public void setUpCountFlow(Integer upCountFlow) {
    
    
        this.upCountFlow = upCountFlow;
    }
    public Integer getDownCountFlow() {
    
    
        return downCountFlow;
    }
    public void setDownCountFlow(Integer downCountFlow) {
    
    
        this.downCountFlow = downCountFlow;
    }
    @Override
    public String toString() {
    
    
        return "FlowBean{" +
                "upFlow=" + upFlow +
                ", downFlow=" + downFlow +
                ", upCountFlow=" + upCountFlow +
                ", downCountFlow=" + downCountFlow +
                '}';
    }
}
Step 2: 定义FlowMapper类
public class FlowCountMapper extends Mapper<LongWritable,Text,Text,FlowBean> {
    
    
    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
    
    
       //1:拆分手机号
        String[] split = value.toString().split("\t");
        String phoneNum = split[1];
        //2:获取四个流量字段
        FlowBean flowBean = new FlowBean();
        flowBean.setUpFlow(Integer.parseInt(split[6]));
        flowBean.setDownFlow(Integer.parseInt(split[7]));
        flowBean.setUpCountFlow(Integer.parseInt(split[8]));
        flowBean.setDownCountFlow(Integer.parseInt(split[9]));

        //3:将k2和v2写入上下文中
        context.write(new Text(phoneNum), flowBean);
    }
}
Step 3: 定义FlowReducer类
public class FlowCountReducer extends Reducer<Text,FlowBean,Text,FlowBean> {
    
    
    @Override
    protected void reduce(Text key, Iterable<FlowBean> values, Context context) throws IOException, InterruptedException {
    
    
       //封装新的FlowBean
        FlowBean flowBean = new FlowBean();
        Integer upFlow = 0;
        Integer  downFlow = 0;
        Integer upCountFlow = 0;
        Integer downCountFlow = 0;
        for (FlowBean value : values) {
    
    
            upFlow  += value.getUpFlow();
            downFlow += value.getDownFlow();
            upCountFlow += value.getUpCountFlow();
            downCountFlow += value.getDownCountFlow();
        }
        flowBean.setUpFlow(upFlow);
        flowBean.setDownFlow(downFlow);
        flowBean.setUpCountFlow(upCountFlow);
        flowBean.setDownCountFlow(downCountFlow);
        //将K3和V3写入上下文中
        context.write(key, flowBean);
    }
}
Step 4: 程序main函数入口FlowMain
public class JobMain extends Configured implements Tool {
    
    

    //该方法用于指定一个job任务
    @Override
        public int run(String[] args) throws Exception {
    
    
        //1:创建一个job任务对象
        Job job = Job.getInstance(super.getConf(), "mapreduce_flowcount");
        //如果打包运行出错，则需要加该配置
        job.setJarByClass(JobMain.class);
        //2:配置job任务对象(八个步骤)

        //第一步:指定文件的读取方式和读取路径
        job.setInputFormatClass(TextInputFormat.class);
        //TextInputFormat.addInputPath(job, new Path("hdfs://node01:8020/wordcount"));
        TextInputFormat.addInputPath(job, new Path("file:///D:\\input\\flowcount_input"));



        //第二步:指定Map阶段的处理方式和数据类型
         job.setMapperClass(FlowCountMapper.class);
         //设置Map阶段K2的类型
          job.setMapOutputKeyClass(Text.class);
        //设置Map阶段V2的类型
          job.setMapOutputValueClass(FlowBean.class);


          //第三（分区），四 （排序）
          //第五步: 规约(Combiner)
          //第六步 分组


          //第七步：指定Reduce阶段的处理方式和数据类型
          job.setReducerClass(FlowCountReducer.class);
          //设置K3的类型
           job.setOutputKeyClass(Text.class);
          //设置V3的类型
           job.setOutputValueClass(FlowBean.class);

           //第八步: 设置输出类型
           job.setOutputFormatClass(TextOutputFormat.class);
           //设置输出的路径
           TextOutputFormat.setOutputPath(job, new Path("file:///D:\\out\\flowcount_out"));



        //等待任务结束
           boolean bl = job.waitForCompletion(true);

           return bl ? 0:1;
    }

    public static void main(String[] args) throws Exception {
    
    
        Configuration configuration = new Configuration();

        //启动job任务
        int run = ToolRunner.run(configuration, new JobMain(), args);
        System.exit(run);

    }
}

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

需求二: 上行流量倒序排序（递减排序）

分析，以需求一的输出数据作为排序的输入数据，自定义FlowBean,以FlowBean为map输出的key，以手机号作为Map输出的value，因为MapReduce程序会对Map阶段输出的key进行排序

Step 1: 定义FlowBean实现WritableComparable实现比较排序

Java 的 compareTo 方法说明:

  • compareTo 方法用于将当前对象与方法的参数进行比较。
  • 如果指定的数与参数相等返回 0。
  • 如果指定的数小于参数返回 -1。
  • 如果指定的数大于参数返回 1。

例如：o1.compareTo(o2); 返回正数的话，当前对象（调用 compareTo 方法的对象 o1）要排在比较对象（compareTo 传参对象 o2）后面，返回负数的话，放在前面

public class FlowBean implements WritableComparable<FlowBean> {
    
    
    private Integer upFlow;
    private Integer  downFlow;
    private Integer upCountFlow;
    private Integer downCountFlow;
    public FlowBean() {
    
    
    }

    public FlowBean(Integer upFlow, Integer downFlow, Integer upCountFlow, Integer downCountFlow) {
    
    
        this.upFlow = upFlow;
        this.downFlow = downFlow;
        this.upCountFlow = upCountFlow;
        this.downCountFlow = downCountFlow;
    }

    @Override
    public void write(DataOutput out) throws IOException {
    
    
        out.writeInt(upFlow);
        out.writeInt(downFlow);
        out.writeInt(upCountFlow);
        out.writeInt(downCountFlow);
    }

    @Override
    public void readFields(DataInput in) throws IOException {
    
    
        upFlow = in.readInt();
        downFlow = in.readInt();
        upCountFlow = in.readInt();
        downCountFlow = in.readInt();
    }

    public Integer getUpFlow() {
    
    
        return upFlow;
    }

    public void setUpFlow(Integer upFlow) {
    
    
        this.upFlow = upFlow;
    }
    
    public Integer getDownFlow() {
    
    
        return downFlow;
    }
    
    public void setDownFlow(Integer downFlow) {
    
    
        this.downFlow = downFlow;
    }
    
    public Integer getUpCountFlow() {
    
    
        return upCountFlow;
    }
    public void setUpCountFlow(Integer upCountFlow) {
    
    
        this.upCountFlow = upCountFlow;
    }
    public Integer getDownCountFlow() {
    
    
        return downCountFlow;
    }
    public void setDownCountFlow(Integer downCountFlow) {
    
    
        this.downCountFlow = downCountFlow;
    }
    @Override
    public String toString() {
    
    
        return upFlow+"\t"+downFlow+"\t"+upCountFlow+"\t"+downCountFlow;
    }
    @Override
    public int compareTo(FlowBean o) {
    
    
        return this.upCountFlow > o.upCountFlow ?-1:1;
    }
}
Step 2: 定义FlowMapper
public class FlowCountSortMapper extends Mapper<LongWritable,Text,FlowBean,Text> {
    
    
    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
    
    
        FlowBean flowBean = new FlowBean();
        String[] split = value.toString().split("\t");

        //获取手机号，作为V2
        String phoneNum = split[0];
        //获取其他流量字段,封装flowBean，作为K2
        flowBean.setUpFlow(Integer.parseInt(split[1]));
        flowBean.setDownFlow(Integer.parseInt(split[2]));
        flowBean.setUpCountFlow(Integer.parseInt(split[3]));
        flowBean.setDownCountFlow(Integer.parseInt(split[4]));

        //将K2和V2写入上下文中
        context.write(flowBean, new Text(phoneNum));

    }
}
Step 3: 定义FlowReducer
public class FlowCountSortReducer extends Reducer<FlowBean,Text,Text,FlowBean> {
    
    
    @Override
    protected void reduce(FlowBean key, Iterable<Text> values, Context context) throws IOException, InterruptedException {
    
    
        for (Text value : values) {
    
    
            context.write(value, key);
        }
    }
}
Step 4: 程序main函数入口
public class JobMain extends Configured  implements Tool {
    
    
    @Override
    public int run(String[] strings) throws Exception {
    
    
        //创建一个任务对象
        Job job = Job.getInstance(super.getConf(), "mapreduce_flowcountsort");

        //打包放在集群运行时，需要做一个配置
        job.setJarByClass(JobMain.class);
        //第一步:设置读取文件的类: K1 和V1
        job.setInputFormatClass(TextInputFormat.class);
        TextInputFormat.addInputPath(job, new Path("hdfs://node01:8020/out/flowcount_out"));

        //第二步：设置Mapper类
        job.setMapperClass(FlowCountSortMapper.class);
        //设置Map阶段的输出类型: k2 和V2的类型
        job.setMapOutputKeyClass(FlowBean.class);
        job.setMapOutputValueClass(Text.class);

        //第三,四，五，六步采用默认方式(分区，排序，规约，分组)


        //第七步 ：设置文的Reducer类
        job.setReducerClass(FlowCountSortReducer.class);
        //设置Reduce阶段的输出类型
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(FlowBean.class);

        //设置Reduce的个数

        //第八步:设置输出类
        job.setOutputFormatClass(TextOutputFormat.class);
        //设置输出的路径
        TextOutputFormat.setOutputPath(job, new Path("hdfs://node01:8020/out/flowcountsort_out"));


        boolean b = job.waitForCompletion(true);
        return b?0:1;

    }
    public static void main(String[] args) throws Exception {
    
    
        Configuration configuration = new Configuration();

        //启动一个任务
        int run = ToolRunner.run(configuration, new JobMain(), args);
        System.exit(run);
    }

}

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

需求三: 手机号码分区

在需求一的基础上，继续完善，将不同的手机号分到不同的数据文件的当中去，需要自定义分区来实现，这里我们自定义来模拟分区，将以下数字开头的手机号进行分开

135 开头数据到一个分区文件
136 开头数据到一个分区文件
137 开头数据到一个分区文件
其他分区
自定义分区
public class FlowPartition extends Partitioner<Text,FlowBean> {
    
    
    @Override
    public int getPartition(Text text, FlowBean flowBean, int i) {
    
    
        String line = text.toString();
        if (line.startsWith("135")){
    
    
            return 0;
        }else if(line.startsWith("136")){
    
    
            return 1;
        }else if(line.startsWith("137")){
    
    
            return 2;
        }else{
    
    
            return 3;
        }
    }
}
作业运行设置
job.setPartitionerClass(FlowPartition.class);
 job.setNumReduceTasks(4);
修改输入输出路径, 并放入集群运行
TextInputFormat.addInputPath(job,new Path("hdfs://node01:8020/partition_flow/"));
TextOutputFormat.setOutputPath(job,new Path("hdfs://node01:8020/partition_out"));

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

猜你喜欢

转载自blog.csdn.net/qq_38454176/article/details/105711576
今日推荐
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
OOP第二次作业
java web 乱码问题
android 禁止scrollview 因控件变化自动滚动到底的方法
mysql服务解压版的安装(5.7)
centos7 nginx+tomcat配置https 安装免费SSL Let’s Encrypt
使用Mosquitto遗嘱机制实现感知客户端上下线功能的方法
面向对象之------多态与多态性
开发Teams Tabs应用程序
C# 希尔排序
第2章 Jupyter Notebooks
每日归档
更多
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022