【MapReduce】实战：流量统计（完整Java代码）

最新推荐文章于 2024-05-14 21:30:47 发布
最新推荐文章于 2024-05-14 21:30:47 发布
阅读量3.7k 收藏 42
点赞数 4
分类专栏： 大数据相关技术汇总 文章标签： hadoop 大数据 mapreduce java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45650899/article/details/109691011
版权

【MapReduce】系列学习笔记：

文章目录

1 需求

根据数据文件phone_data.txt按照如下要求实现MapReduce分析程序编写：

需求：

1）统计每一个手机号耗费的总上行流量、下行流量、总流量
2）将统计结果按照手机归属地不同号段(手机号前3位)输出到不同文件中
3）根据需求1）产生的结果再次对总流量进行排序。
4）按照要求2）每个手机号段输出的文件中按照总流量内部排序。

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

输出数据格式：
在这里插入图片描述

2 实验环境

实验环境版本
操作系统Linux（Centos7）
JDKjdk 1.8.0_271
IDEIntelliJ IDEA 2020.2
Hadoop3.2.1

3 实验内容

3.1 数据准备

本次实验的数据为所提供的phone_data数据，单行数据包括手机号码、MAC地址、IP地址、上行流量、下行流量等，部分数据如下图所示：

3.2 分析和设计

根据本次实验的四个功能模块，结合MapReduce的过程，具体的流程设计如下：

统计求和

在这里插入图片描述

在MapReduce的过程中：

K1:行数量 V1:每一行的数据

K2:电话号码 V2:由上行流量和下行流量构建的PhoneFlow类

K3:电话号码 V3:由所有的上行流量之和和所有的下行流量之和构建的PhoneFlow类

分区

在这里插入图片描述

与第一个实验不同的是加入了分区类，在分区类中，分为134、135、136、137、138、139和其他7个分区，分别返回0、1、2、3、4、5、6。

总体排序

在这里插入图片描述

该实验使用经过第一次实验已经处理过的数据作为输入文件，对于PhoneFlow类继承了WritableComparable，重写了CompareTo方法用于比较大小，在后续使用该类是会自动按照规则进行排序。

其中：
K1:行数 V1:每一行的数据

K2:PhoneFlow类 V2:手机号码

K3:手机号码 V3:PhoneFlow类

分区排序


其中：

K1:行数 V1:每一行的数据

K2:PhoneFlow类 V2:手机号码

K3:手机号码 V3:PhoneFlow类

4 编码

4.1 统计求和

PhoneFlow

package com.tao.CountFlow;

import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Writable;

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

/**
 * @author zhangtao
 * 封装上行流量、下行流量、总流量
 */
public class PhoneFlow implements Writable{

    private Long up;
    private Long down;
    private Long sum;

    public PhoneFlow() {
    }
    public PhoneFlow(Long up, Long down) {
        this.up = up;
        this.down = down;
        this.sum = up+down;
    }

    public Long getUp() {
        return up;
    }

    public void setUp(Long up) {
        this.up = up;
    }

    public Long getDown() {
        return down;
    }

    public void setDown(Long down) {
        this.down = down;
    }

    public Long getSum() {
        return sum;
    }

    public void setSum(Long sum) {
        this.sum = sum;
    }

    @Override
    public String toString() {
        return  String.valueOf(up) + "   "+String.valueOf(down) +"   "+ String.valueOf(sum);
    }


    public void write(DataOutput dataOutput) throws IOException {
        dataOutput.writeLong(up);
        dataOutput.writeLong(down);
        dataOutput.writeLong(sum);
    }

    public void readFields(DataInput dataInput) throws IOException {
        up = dataInput.readLong();
        down = dataInput.readLong();
        sum = dataInput.readLong();
    }


}

Mapper

package com.tao.CountFlow;

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

import java.io.IOException;

/**
 * @author zhangtao
 */
public class PhoneFlowMapper extends Mapper<LongWritable,Text, Text, PhoneFlow> {
    @Override
    /**
     * 参数：
     *     key：k1 行偏移量
     *     value：v1 每一行的文本数据
     *     context：表示上下文对象
     */
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {

        //1、将每一行的内容转换为string并进行拆分
        String[] split = value.toString().split("\\s+");
        //2、获取手机号码、上行流量、下行流量
        String phoneNumber = split[1];
        long up = Long.parseLong(split[split.length-3]);
        long down = Long.parseLong(split[split.length-2]);

        //3、写入上下文
        context.write(new Text(phoneNumber), new PhoneFlow(up, down));
    }
}

Reudcer

package com.tao.CountFlow;

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

import java.io.IOException;

/**
 * @author zhangtao
 */
public class PhoneFlowReducer extends Reducer<Text,PhoneFlow,Text,PhoneFlow> {

    @Override
    protected void reduce(Text key, Iterable<PhoneFlow> values, Context context) throws IOException, InterruptedException {
        long sumUp = 0;
        long sumDown = 0;
        //1、将所有的上行流量和下行流量求和
        for(PhoneFlow phoneFlow :values){
            sumUp = sumUp + phoneFlow.getUp();
            sumDown = sumDown + phoneFlow.getDown();
        }
        //2、获取总流量
        PhoneFlow phoneFlow = new PhoneFlow(sumUp,sumDown);
        //3、写入上下文
        context.write(key,phoneFlow);
    }
}

Main

package com.tao.CountFlow;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.conf.Configured;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
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;

import java.net.URI;

/**
 * @author zhangtao
 */
public class PhoneFlowMain extends Configured implements Tool {
    /**
     * 该方法用于指定一个job任务
     */
    public int run(String[] strings) throws Exception {
        //1、创建一个job
        Job job = Job.getInstance(super.getConf(),"phoneFlow");

        //2、配置job任务对象(八个步骤)

        //第一步：指定文件的读取方式和读取路径
        job.setInputFormatClass(TextInputFormat.class);
        TextInputFormat.addInputPath(job,new Path("hdfs://192.168.164.134:9000/PhoneData"));

        //第二步：指定map阶段的处理方式和数据类型
        job.setMapperClass(PhoneFlowMapper.class);
        job.setJarByClass(PhoneFlowMapper.class);
        //设置map阶段k2的类型
        job.setMapOutputKeyClass(Text.class);
        //设置map阶段v2的类型
        job.setMapOutputValueClass(PhoneFlow.class);

        //第三、四、五、六步：shuffle 采用默认的方式

        //第七步：指定reduce阶段的处理方式和数据类型
        job.setReducerClass(PhoneFlowReducer.class);
        job.setJarByClass(PhoneFlowReducer.class);
        //设置k3的类型
        job.setOutputKeyClass(Text.class);
        //设置v3的类型
        job.setOutputValueClass(PhoneFlow.class);

        //第八步：设置输出类型
        job.setOutputFormatClass(TextOutputFormat.class);
        //设置输出的路径
        Path path = new Path("hdfs://192.168.164.134:9000/out/PhoneFlow_out");
        TextOutputFormat.setOutputPath(job,path);
        FileSystem fs = FileSystem.get(new URI("hdfs://192.168.164.134:9000"),new Configuration());
        if(fs.exists(path)){
            fs.delete(path,true);
        }
        //等待任务结束
        boolean b1 = job.waitForCompletion(true);

        return b1? 0:1;
    }

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

4.2 分区

Partitioner

package com.tao.LocationPart;

import com.tao.CountFlow.PhoneFlow;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Partitioner;

/**
 * @author zhangtao
 * 输入类型和map阶段相同
 */
public class MyPartitioner extends Partitioner<Text, PhoneFlow> {

    @Override
    public int getPartition(Text text, PhoneFlow phoneFlow, int i) {
        //1、获取前三位号码
        String num = text.toString().substring(0,3);
        //2、观察文档，有134、135、136、137、138、139、182、841、159、150、183开头的地区
        //设置分区为134、135、136、137、138、139和其他
        int part = 6;
        String p1 = "134";
        String p2 = "135";
        String p3 = "136";
        String p4 = "137";
        String p5 = "138";
        String p6 = "139";
        if(p1.equals(num)){
            part = 0;
        }
        if(p2.equals(num)){
            part = 1;
        }
        if(p3.equals(num)){
            part = 2;
        }
        if(p4.equals(num)){
            part = 3;
        }
        if(p5.equals(num)){
            part = 4;
        }
        if(p6.equals(num)){
            part = 5;
        }
        return part;
    }
}

Main

package com.tao.LocationPart;

import com.tao.CountFlow.PhoneFlow;
import com.tao.CountFlow.PhoneFlowMapper;
import com.tao.CountFlow.PhoneFlowReducer;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.conf.Configured;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
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;

import java.net.URI;

/**
 * @author zhangtao
 */
public class LocationPartMain extends Configured implements Tool {
    /**
     * 该方法用于指定一个job任务
     */
    public int run(String[] strings) throws Exception {
        //1、创建一个job
        Job job = Job.getInstance(super.getConf(),"locationPart");

        //2、配置job任务对象(八个步骤)

        //第一步：指定文件的读取方式和读取路径
        job.setInputFormatClass(TextInputFormat.class);
        TextInputFormat.addInputPath(job,new Path("hdfs://192.168.164.134:9000/PhoneData"));

        //第二步：指定map阶段的处理方式和数据类型
        job.setMapperClass(PhoneFlowMapper.class);
        job.setJarByClass(PhoneFlowMapper.class);
        //设置map阶段k2的类型
        job.setMapOutputKeyClass(Text.class);
        //设置map阶段v2的类型
        job.setMapOutputValueClass(PhoneFlow.class);

        //第三、四、五、六步：shuffle 采用默认的方式

        //第七步：指定reduce阶段的处理方式和数据类型
        job.setReducerClass(PhoneFlowReducer.class);
        job.setJarByClass(PhoneFlowReducer.class);
        //设置k3的类型
        job.setOutputKeyClass(Text.class);
        //设置v3的类型
        job.setOutputValueClass(PhoneFlow.class);

        //第八步：设置输出类型
        job.setOutputFormatClass(TextOutputFormat.class);
        //设置输出的路径
        Path path = new Path("hdfs://192.168.164.134:9000/out/locationPart_out");
        TextOutputFormat.setOutputPath(job,path);
        FileSystem fs = FileSystem.get(new URI("hdfs://192.168.164.134:9000"),new Configuration());
        if(fs.exists(path)){
            fs.delete(path,true);
        }
        //设置part
        job.setPartitionerClass(MyPartitioner.class);
        //设置分区数量
        job.setNumReduceTasks(7);
        //等待任务结束
        boolean b1 = job.waitForCompletion(true);

        return b1? 0:1;
    }

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

4.3 全排序

PhoneFlow

package com.tao.CountFlowSort;

import com.tao.CountFlow.PhoneFlow;
import org.apache.hadoop.io.Writable;
import org.apache.hadoop.io.WritableComparable;

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

/**
 * @author zhangtao
 * 封装上行流量、下行流量、总流量
 */
public class PhoneFlow2 implements WritableComparable<PhoneFlow2> {

    private Long up;
    private Long down;
    private Long sum;

    public PhoneFlow2() {
    }



    public PhoneFlow2(Long up, Long down) {
        this.up = up;
        this.down = down;
        this.sum = up+down;
    }

    public Long getUp() {
        return up;
    }

    public void setUp(Long up) {
        this.up = up;
    }

    public Long getDown() {
        return down;
    }

    public void setDown(Long down) {
        this.down = down;
    }

    public Long getSum() {
        return sum;
    }

    public void setSum(Long sum) {
        this.sum = sum;
    }

    @Override
    public String toString() {
        return  String.valueOf(up) + "   "+String.valueOf(down) +"   "+ String.valueOf(sum);
    }


    public void write(DataOutput dataOutput) throws IOException {
        dataOutput.writeLong(up);
        dataOutput.writeLong(down);
        dataOutput.writeLong(sum);
    }

    public void readFields(DataInput dataInput) throws IOException {
        up = dataInput.readLong();
        down = dataInput.readLong();
        sum = dataInput.readLong();
    }

    /**
     * 指定排序的规则
     */
    public int compareTo(PhoneFlow2 o) {
        //升序
        return (int) (this.sum-o.getSum());
        //降序
//        return (int) (-this.sum+o.getSum());
    }
}

Mapper

package com.tao.CountFlowSort;

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

import java.io.IOException;

/**
 * @author zhangtao
 * k2:phoneflow
 * v2:手机号
 */
public class FlowSortMapper extends Mapper<LongWritable, Text, PhoneFlow2,Text> {
    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        //拆分v1,获取流量
        String v = value.toString();
        String[] data = v.split("\\s+");

        String phone = data[0];
        long up = Long.parseLong(data[1]);
        long down = Long.parseLong(data[2]);

        //存储k2
        PhoneFlow2 phoneFlow = new PhoneFlow2(up,down);

        //存储v2
        Text text =new Text();
        text.set(phone);

        //存入上下文
        context.write(phoneFlow,text);
    }
}

Reducer

package com.tao.CountFlowSort;

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


import java.io.IOException;


/**
 * @author zhangtao
 *
 * k2:phoneflow
 * v2:phone
 *
 * k3:phone
 * v3:phoneflow
 */
public class FlowSortReducer extends Reducer<PhoneFlow2, Text, Text, PhoneFlow2> {
    @Override
    protected void reduce(PhoneFlow2 key, Iterable<Text> values, Context context) throws IOException, InterruptedException {
        //取出k3，将k3和v3写入上下文
        for(Text value : values){
            context.write(value,key);
        }
    }
}

Main

package com.tao.CountFlowSort;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.conf.Configured;
import org.apache.hadoop.fs.FileSystem;
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.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;
import org.apache.hadoop.util.Tool;
import org.apache.hadoop.util.ToolRunner;

import java.net.URI;

/**
 * @author zhangtao
 */
public class FlowSortMain extends Configured implements Tool {
    /**
     * 该方法用于指定一个job任务
     */
    public int run(String[] strings) throws Exception {
        //1、创建一个job
        Job job = Job.getInstance(super.getConf(),"Flowsort");

        //2、配置job任务对象(八个步骤)

        //第一步：指定文件的读取方式和读取路径
        job.setInputFormatClass(TextInputFormat.class);
        TextInputFormat.addInputPath(job,new Path("hdfs://192.168.164.134:9000/out/PhoneFlow_out"));

        //第二步：指定map阶段的处理方式和数据类型
        job.setMapperClass(FlowSortMapper.class);
        job.setJarByClass(FlowSortMapper.class);
        //设置map阶段k2的类型
        job.setMapOutputKeyClass(PhoneFlow2.class);
        //设置map阶段v2的类型
        job.setMapOutputValueClass(Text.class);

        //第三、四、五、六步：shuffle 采用默认的方式

        //第七步：指定reduce阶段的处理方式和数据类型
        job.setReducerClass(FlowSortReducer.class);
        job.setJarByClass(FlowSortReducer.class);
        //设置k3的类型
        job.setOutputKeyClass(Text.class);
        //设置v3的类型
        job.setOutputValueClass(PhoneFlow2.class);

        //第八步：设置输出类型
        job.setOutputFormatClass(TextOutputFormat.class);
        //设置输出的路径
        Path path = new Path("hdfs://192.168.164.134:9000/out/FlowSort_out");
        TextOutputFormat.setOutputPath(job,path);
        FileSystem fs = FileSystem.get(new URI("hdfs://192.168.164.134:9000"),new Configuration());
        if(fs.exists(path)){
            fs.delete(path,true);
        }
        //等待任务结束
        boolean b1 = job.waitForCompletion(true);

        return b1? 0:1;
    }

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

4.4 内部排序

Partitioner

package com.tao.LocationPartSort;


import com.tao.CountFlowSort.PhoneFlow2;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Partitioner;

/**
 * @author zhangtao
 * 输入类型和map阶段相同
 */
public class MyPartitioner2 extends Partitioner<PhoneFlow2, Text> {

    @Override
    public int getPartition(PhoneFlow2 phoneFlow, Text text, int i) {
        //1、获取前三位号码
        String num = text.toString().substring(0,3);
        //2、观察文档，有134、135、136、137、138、139、182、841、159、150、183开头的地区
        //设置分区为134、135、136、137、138、139和其他
        int part = 6;
        String p1 = "134";
        String p2 = "135";
        String p3 = "136";
        String p4 = "137";
        String p5 = "138";
        String p6 = "139";
        if(p1.equals(num)){
            part = 0;
        }
        if(p2.equals(num)){
            part = 1;
        }
        if(p3.equals(num)){
            part = 2;
        }
        if(p4.equals(num)){
            part = 3;
        }
        if(p5.equals(num)){
            part = 4;
        }
        if(p6.equals(num)){
            part = 5;
        }
        return part;
    }
}

Main

package com.tao.LocationPartSort;

import com.tao.CountFlowSort.FlowSortMapper;
import com.tao.CountFlowSort.FlowSortReducer;
import com.tao.CountFlowSort.PhoneFlow2;
import com.tao.LocationPart.MyPartitioner;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.conf.Configured;
import org.apache.hadoop.fs.FileSystem;
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.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;
import org.apache.hadoop.util.Tool;
import org.apache.hadoop.util.ToolRunner;

import java.net.URI;

/**
 * @author zhangtao
 */
public class LocationPartSortMain extends Configured implements Tool {
    /**
     * 该方法用于指定一个job任务
     */
    public int run(String[] strings) throws Exception {
        //1、创建一个job
        Job job = Job.getInstance(super.getConf(),"LocationPartSort");

        //2、配置job任务对象(八个步骤)

        //第一步：指定文件的读取方式和读取路径
        job.setInputFormatClass(TextInputFormat.class);
        TextInputFormat.addInputPath(job,new Path("hdfs://192.168.164.134:9000/out/FlowSort_out"));

        //第二步：指定map阶段的处理方式和数据类型
        job.setMapperClass(FlowSortMapper.class);
        job.setJarByClass(FlowSortMapper.class);
        //设置map阶段k2的类型
        job.setMapOutputKeyClass(PhoneFlow2.class);
        //设置map阶段v2的类型
        job.setMapOutputValueClass(Text.class);

        //第三、四、五、六步：shuffle 采用默认的方式

        //第七步：指定reduce阶段的处理方式和数据类型
        job.setReducerClass(FlowSortReducer.class);
        job.setJarByClass(FlowSortReducer.class);
        //设置k3的类型
        job.setOutputKeyClass(Text.class);
        //设置v3的类型
        job.setOutputValueClass(PhoneFlow2.class);

        //第八步：设置输出类型
        job.setOutputFormatClass(TextOutputFormat.class);
        //设置输出的路径
        Path path = new Path("hdfs://192.168.164.134:9000/out/LocationPartSort_out");
        TextOutputFormat.setOutputPath(job,path);
        FileSystem fs = FileSystem.get(new URI("hdfs://192.168.164.134:9000"),new Configuration());
        if(fs.exists(path)){
            fs.delete(path,true);
        }
        //设置part
        job.setPartitionerClass(MyPartitioner2.class);
        //设置分区数量
        job.setNumReduceTasks(7);
        //等待任务结束
        boolean b1 = job.waitForCompletion(true);

        return b1? 0:1;
    }

    public static void main(String[] args) throws Exception {
        Configuration conf = new Configuration();
        //启动job任务
        int run = ToolRunner.run(conf,new LocationPartSortMain(),args);
        System.exit(run);
    }
}
快乐的冲浪码农
关注
  • 4
    点赞
  • 踩
  • 42
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
基于MapReduce的流量统计（完整Java代码）包括源文件、输出文件、jar包、代码
11-14
根据数据文件phone_data.txt按照如下要求实现MapReduce分析程序编写： 需求： 1）统计每一个手机号耗费的总上行流量、下行流量、总流量 2）将统计结果按照手机归属地不同号段(手机号前3位)输出到不同文件中 3）根据需求1）产生的结果再次对总流量进行排序。 4）按照要求2）每个手机号段输出的文件中按照总流量内部排序。
通过Java编写MapReduce程序，统计每一个手机号耗费的总上行流量、下行流量、总流量，并且按照不同的手机号输出到不同的文件中
weixin_46119343的博客
12-22 2468
题目 通过Java编写MapReduce程序，统计每一个手机号耗费的总上行流量、下行流量、总流量，并且按照不同的归属地输出到不同的文件中 本题声明： 1.采用Linux系统 2.已搭建好的hadoop集群 3.使用java编写MapReduce程序 题目分析： 1.编写MapReduce程序 2.hadoop调用MapReduce程序的数据源要上传至集群当中 项目流程： 我将该项目分成了两步来做 (1) 通过数据源文件，首先求出每个手机号的总上行流量、下行流量、总流量。 (2) 根据(1)的手机号流量汇总结
MapReduce代码
Saniana的博客
05-14 726
wordcount 流量统计
Java实现网站请求流量分析统计
我的青春一去不复返
04-15 2621
如上图所描绘的，在不断刷新test.html请求页面时，上图total.html页面会实时的更新（1秒响应更新一次），折线图会实时进行上下变动。其中需要导入echarts.min.js和jquery-3.5.1.min.js包。 0.首先是创建RequestServlet这个类，创建一个时间集合和与之相对象的值集合，就是每一时间段，有多少的请求数量。比如上图19:14时间段有20多个请求量。代码如下： package com.wei.total; import java.io.IOExce...
java调用大华SDK实现人流量统计
m0_37849268的博客
03-16 2248
以下内容都是自己最近做的真实项目总结的经验，一些需要注意的地方我在下面都有做说明，希望可以给刚接触大华sdk调用的兄弟一些建议，少走一些弯路！另外大华的文档写的也很详细，都可以对着看！
MapReduce编程规范及实践（流量统计）
m0_37956825的博客
05-16 1138
一、MapReduce编码规范 Map阶段2个步骤 设置 InputFormat 类, 将数据切分为 Key-Value(K1和V1) 对, 输入到第二步 自定义 Map 逻辑, 将第一步的结果转换成另外的 Key-Value(K2和V2) 对, 输出结果 Shule 阶段 4 个步骤 对输出的 Key-Value 对进行 分区 对不同分区的数据按照相同的 Key 排序 (可选) 对分组过的数据初步 规约 , 降低数据的网络拷贝 对数据进行 分组 ,
大数据---15.Mapreduce案例之---统计手机号耗费的总上行流量、下行流量、总流量
u014579001的博客
04-19 6282
MapReduce的封装对象的例子
（头歌）MapReduce的编程开发-求和（统计手机用户总流量）
weixin_63311205的博客
12-21 1549
求和是 MapReduce 中最常见的数值算法，使用 Map 端读取数据，若只需要针对单行数据进行求和的话，只 Map 端就可以满足了。若需要针对多行数据进行分组求和的话，那就需要 Map 端和 Reducer 端相结合，以 key 值区分来将所有数值进行求和，达到分组求和的效果。
MapReduce:一些示例 MapReduce 代码
06-21
一个充满示例 MapReduce 代码的存储库。 要求 这些示例只需要一本好的电子书即可。 一个受欢迎的地方是 。 一旦你有一两本书，它们必须放在 HDFS 上的输入目录中才能使这些示例工作。 项目 这是所有项目的列表以及...
MapReduce的词频统计JAVA源码
最新发布
06-26
在进行Hadoop架构实验中实现的两个案例中WordCount.java源码，具体操作见厦门大学大数据技术实验课博客
MapReduce框架统计流量模板数据
09-16
为MapReduce框架对电话号码的上行流量和下行流量及总流量进行统计的模板数据
MapReduce:CS 6240 MapReduce 代码
07-08
在CS 6240 MapReduce课程中，你可能会深入学习这种编程模型以及如何使用Java实现它。 **Map阶段**： Map阶段是MapReduce的第一个步骤，它的任务是对输入数据进行预处理。输入数据通常是以键值对的形式存在，例如...
java 网络流量统计_IP数据包的流量统计(JAVA语言)
weixin_30297493的博客
02-16 2924
如果不显示图片，或者出现排版错误，抽风，崩坏，节操丢失等一系列不正常情况，请点击下面链接观看，点我IP数据包的流量统计(JAVA语言)要求:编制程序,监控网络,捕获一段时间内网络上的IP数据包,按数据包的源地址统计出该源地址在该时间段发出的IP包的个数,将其写入日志文件中或者用图形表示出来.课程设计,感觉挺有意思的.就想做出来,但自己虽然学过一点JAVA语言但是有些东西并不会,并且对网络协议也不是...
基于MapReduce的手机上网流量统计分析
什么最重要？算法！！
07-06 5894
Hadoop简介：适合大数据的分布式存储与计算平台。 运行在Hadoop之上的大型服务器集群： 数据情况：（摘取部分） 字段描述：时间戳、手机号码、AP mac、AP mac、访问的网址、网址种类、上行数据包、下行数据包、流量、访问状态。 手机上网流量统计结果：(先展示统计部分结果) MapReduce程序开发步骤： 1、maper函数的编写 2、reducer函数的编写
使用eclipse实现MapReduce实践编程---统计不同手机号的用户使用的总流量
weixin_45332508的博客
10-30 1885
根据用户手机上网的行为记录，基于 MapReduce编程模型设计程序统计不同手机号的用户使用的总流量。
4 Hadoop-Mapreduce
PhoenixLuo·的博客
05-03 683
目录 4.4 MapReduce 4.4.1 MapReduce 介绍 MapReduce 设计构思 4.4.2 MapReduce 编程规范 4.4.3 WordCount(经典案例） Step 1. 数据格式准备 Step 2. Mapper Step 3. Reducer Step 4. 定义主类, 描述 Job 并提交 Job 4.4.4 MapReduce 运行模式 集群运行模式 本地运行模式 （一般做测试用） 4.4.5 MapReduce 分区 Step 1. 定义
MapReduce序列化【用户流量使用统计】
梦想是动物管理员
05-12 2569
MapReduce自定义序列化实例
使用MapReduce编程统计网站每日的流量总数
m0_58540923的博客
08-11 873
使用MapReduce统计网站每日的流量总数，输入文件路径为/user/root/logstat/input，请将计算后的结果输出到/user/ root/logstat/output/目录下。2. 编写MapReduce程序首先需要考虑Map阶段和Reduce阶段各自的处理逻辑。2. 编写MapReduce程序首先需要考虑Map阶段和Reduce阶段各自的处理逻辑。（2）掌握用MapReduce解决一些常见的数据预处理方法，包括数据清洗、词频统计等。）对网站流量日志数据预处理功能进行测试。
MapReduce入门编程及源码详解
qq_46439199的博客
11-16 2053
MapReduce基础编程（源码篇）
MapReduce流程：
06-10
MapReduce 是一种分布式计算框架，能够将大规模数据集分割成小块，然后在多台计算机上并行处理这些小块数据，最后将结果合并起来。其主要流程如下： 1. Map 阶段：在这个阶段，MapReduce 将大规模数据集划分成小块，然后在每个小块上运行 Map 函数，将其转换为键值对的形式，并将输出结果写入本地磁盘。 2. Shuffle 阶段：在这个阶段，MapReduce 将 Map 函数的输出结果根据键值对重新分配到不同的机器上，以便进行下一步的 Reduce 操作。这个过程需要进行网络传输，因此需要耗费一定的时间和带宽。 3. Reduce 阶段：在这个阶段，MapReduce 将每个机器上的键值对进行合并和处理，并将结果写入输出文件。Reduce 函数的输入是一个键和一组具有该键的值，输出是一组经过归约计算后的结果。 4. 输出阶段：在这个阶段，MapReduce 将每个 Reduce 函数的输出结果合并成最终的输出文件，并将该文件存储到分布式文件系统中。 整个 MapReduce 过程是自动化的，程序员只需要编写 Map 和 Reduce 函数，并指定输入和输出路径即可。同时，MapReduce 还具有容错性和自动恢复功能，能够在单个计算机或网络中断时自动重启任务，从而保证整个过程的可靠性和稳定性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

快乐的冲浪码农

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值