基于Spark对某移动APP流量访问日志分析(Java版)

简介: 笔记

需求分析


我们来根据移动设备唯一标识deviceID来计算来自客户端用户访问日志请求和响应的上行流量、下行流量的记录。


上行流量:指的是手机app向服务器发送的请求数据的流量

下行流量:指的是服务器端给手机app返回的数据(比如说图片、文字、json)的流量

1.计算每个设备(deviceID)总上行流量之和与下行流量之和(取时间戳取最小的deviceID)

eg: 
时间戳 设备号 上行流量    下行流量
1   001   79976   11496
2   001   95291   89092
3   002   57029   93467   -> LogInfo(1, 001, 79976+95291+20428, 11496+89092+57706)
4   001   20428   57706
5   003   5291    9092

2.根据上行流量和下行流量进行排序

优先根据上行流量进行排序,如果上行流量相等,那么根据下行流量排序。如果上行流量和下行流量都相当,那么就根据最早时间戳类排序,即需要二次排序)

3.获取流量最大的前10个设备


数据原型

时间戳(timeStamp)  设备号(deviceID)           上行流量  下行流量
1454307391161 77e3c9e1811d4fb291d0d9bbd456bb4b  79976 11496
1454315971161 f92ecf8e076d44b89f2d070fb1df7197  95291 89092
1454304331161 3de7d6514f1d4ac790c630fa63d8d0be  57029 50228
1454303131161 dd382d2a20464a74bbb7414e429ae452  20428 93467
1454319991161 bb2956150d6741df875fbcca76ae9e7c  51994 57706
...

设计思路


1.自定义数据类型LogInfo(timeStamp,upTraffic,downTraffic)

2.将rdd映射成key-value方式<diviceId,LogInfo>

3.根据diviceId进行聚合,timeStamp取最小值,upTraffic为上行流量总和,downTraffic为下行流量总和

4.自定义一个键值对的比较类来实现比较,要实现Ordered接口和Serializable接口,在key中实现自己对多个列的排序算法。

5.将<diviceId, LogInfo(timeStamp,upTraffic,downTraffic)>映射成<LogSort(timeStamp,upTraffic,downTraffic),diviceId>

6.使用sortByKey算子按照自定义的key进行排序

7.使用take算子取出前n名

8.将排序过的value值打印输出

数据模型及演化过程

时间戳 设备号 上行流量    下行流量  <diviceId, LogInfo(timeStamp,upTraffic,downTraffic)>  <diviceId, LogInfo(timeStamp,upTraffic,downTraffic)>  <LogSort(timeStamp,upTraffic,downTraffic),diviceId>
1   001   10        20         <001,LogInfo(1,10,20)>
2   001   20        15         <001,LogInfo(2,20,15)>                    <001,LogInfo(1,70,55)>                <LogSort(1,70,55),001>
3   002   25        10    map() -> <002,LogInfo(3,25,10)>           reduceByKey() -> <002,LogInfo(3,25,10)>           map() -> <LogSort(3,25,10),002>           sortByKey(false) -> take(n) 
4   001   30        20         <001,LogInfo(4,30,20)>                    <003,LogInfo(5,10,20)>                <LogSort(5,10,20),003>
5   003   10        20         <003,LogInfo(5,10,20)>

1.png



实施过程


首先将SparkConf分装在一个类中

package com.kfk.spark.common;
import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaSparkContext;
/**
 * @author : 蔡政洁
 * @email :caizhengjie888@icloud.com
 * @date : 2020/11/28
 * @time : 6:18 下午
 */
public class CommSparkContext {
    public static JavaSparkContext getsc(){
        SparkConf sparkConf = new SparkConf().setAppName("CommSparkContext").setMaster("local");
        return new JavaSparkContext(sparkConf);
    }
}

自定义数据类型LogInfo

package com.kfk.spark.traffic_analysis_project;
import java.io.Serializable;
/**
 * @author : 蔡政洁
 * @email :caizhengjie888@icloud.com
 * @date : 2020/11/30
 * @time : 6:40 下午
 */
public class LogInfo implements Serializable {
    private long timeStamp;
    private long upTraffic;
    private long downTraffic;
    public long getTimeStamp() {
        return timeStamp;
    }
    public void setTimeStame(long timeStame) {
        this.timeStamp = timeStame;
    }
    public long getUpTraffic() {
        return upTraffic;
    }
    public void setUpTraffic(long upTraffic) {
        this.upTraffic = upTraffic;
    }
    public long getDownTraffic() {
        return downTraffic;
    }
    public void setDownTraffic(long downTraffic) {
        this.downTraffic = downTraffic;
    }
    public LogInfo(){
    }
    public LogInfo(long timeStame, long upTraffic, long downTraffic) {
        this.timeStamp = timeStame;
        this.upTraffic = upTraffic;
        this.downTraffic = downTraffic;
    }
}

自定义key排序类LogSort

package com.kfk.spark.traffic_analysis_project;
import scala.Serializable;
import scala.math.Ordered;
/**
 * @author : 蔡政洁
 * @email :caizhengjie888@icloud.com
 * @date : 2020/11/30
 * @time : 7:39 下午
 */
public class LogSort extends LogInfo implements Ordered<LogSort> , Serializable {
    private long timeStamp;
    private long upTraffic;
    private long downTraffic;
    @Override
    public long getTimeStamp() {
        return timeStamp;
    }
    public void setTimeStamp(long timeStamp) {
        this.timeStamp = timeStamp;
    }
    @Override
    public long getUpTraffic() {
        return upTraffic;
    }
    @Override
    public void setUpTraffic(long upTraffic) {
        this.upTraffic = upTraffic;
    }
    @Override
    public long getDownTraffic() {
        return downTraffic;
    }
    @Override
    public void setDownTraffic(long downTraffic) {
        this.downTraffic = downTraffic;
    }
    public LogSort(){
    }
    public LogSort(long timeStamp, long upTraffic, long downTraffic) {
        this.timeStamp = timeStamp;
        this.upTraffic = upTraffic;
        this.downTraffic = downTraffic;
    }
    public int compare(LogSort that) {
        int comp = Long.valueOf(this.getUpTraffic()).compareTo(that.getUpTraffic());
        if (comp == 0){
            comp = Long.valueOf(this.getDownTraffic()).compareTo(that.getDownTraffic());
        }
        if (comp == 0){
            comp = Long.valueOf(this.getTimeStamp()).compareTo(that.getTimeStamp());
        }
        return comp;
    }
    public boolean $less(LogSort that) {
        return false;
    }
    public boolean $greater(LogSort that) {
        return false;
    }
    public boolean $less$eq(LogSort that) {
        return false;
    }
    public boolean $greater$eq(LogSort that) {
        return false;
    }
    public int compareTo(LogSort that) {
        int comp = Long.valueOf(this.getUpTraffic()).compareTo(that.getUpTraffic());
        if (comp == 0){
            comp = Long.valueOf(this.getDownTraffic()).compareTo(that.getDownTraffic());
        }
        if (comp == 0){
            comp = Long.valueOf(this.getTimeStamp()).compareTo(that.getTimeStamp());
        }
        return comp;
    }
}

编写主类LogApp

package com.kfk.spark.traffic_analysis_project;
import com.kfk.spark.common.CommSparkContext;
import org.apache.spark.api.java.JavaPairRDD;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.Function2;
import org.apache.spark.api.java.function.PairFunction;
import scala.Tuple2;
import java.util.List;
/**
 * @author : 蔡政洁
 * @email :caizhengjie888@icloud.com
 * @date : 2020/11/30
 * @time : 6:36 下午
 */
public class LogApp {
    /**
     * rdd映射成key-value方式<diviceId,LogInfo>
     * rdd map() -> <diviceId,LogInfo(timeStamp,upTraffic,downTraffic)>
     * @param rdd
     * @return
     */
    public static JavaPairRDD<String,LogInfo> mapToPairValues(JavaRDD<String> rdd){
        JavaPairRDD<String,LogInfo> mapToPairRdd =  rdd.mapToPair(new PairFunction<String, String, LogInfo>() {
            public Tuple2<String, LogInfo> call(String line) throws Exception {
                long timeStamp = Long.parseLong(line.split("\t")[0]);
                String diviceId = String.valueOf(line.split("\t")[1]);
                long upTraffic = Long.parseLong(line.split("\t")[2]);
                long downTraffic = Long.parseLong(line.split("\t")[3]);
                LogInfo logInfo = new LogInfo(timeStamp,upTraffic,downTraffic);
                return new Tuple2<String, LogInfo>(diviceId,logInfo);
            }
        });
        return mapToPairRdd;
    }
    /**
     * 根据diviceId进行聚合
     * mapToPairRdd reduceByKey() -> <diviceId,LogInfo(timeStamp,upTraffic,downTraffic)>
     * @param mapPairRdd
     * @return
     */
    public static JavaPairRDD<String,LogInfo> reduceByKeyValues(JavaPairRDD<String,LogInfo> mapPairRdd){
        JavaPairRDD<String,LogInfo> reduceByKeyRdd = mapPairRdd.reduceByKey(new Function2<LogInfo, LogInfo, LogInfo>() {
            public LogInfo call(LogInfo v1, LogInfo v2) throws Exception {
                long timeStamp = Math.min(v1.getTimeStamp(), v2.getTimeStamp());
                long upTraffic = v1.getUpTraffic() + v2.getUpTraffic();
                long downTraffic = v1.getDownTraffic() + v2.getDownTraffic();
                LogInfo logInfo = new LogInfo();
                logInfo.setTimeStame(timeStamp);
                logInfo.setUpTraffic(upTraffic);
                logInfo.setDownTraffic(downTraffic);
                return logInfo;
            }
        });
        return reduceByKeyRdd;
    }
    /**
     * reduceByKeyRdd map() -> <LogSort(timeStamp,upTraffic,downTraffic),diviceId>
     * @param aggregateByKeyRdd
     * @return
     */
    public static JavaPairRDD<LogSort,String> mapToPairSortValues(JavaPairRDD<String,LogInfo> aggregateByKeyRdd){
        JavaPairRDD<LogSort,String> mapToPairSortRdd = aggregateByKeyRdd.mapToPair(new PairFunction<Tuple2<String, LogInfo>, LogSort, String>() {
            public Tuple2<LogSort, String> call(Tuple2<String, LogInfo> stringLogInfoTuple2) throws Exception {
                String diviceId = stringLogInfoTuple2._1;
                long timeStamp = stringLogInfoTuple2._2.getTimeStamp();
                long upTraffic = stringLogInfoTuple2._2.getUpTraffic();
                long downTraffic = stringLogInfoTuple2._2.getDownTraffic();
                LogSort logSort = new LogSort(timeStamp,upTraffic,downTraffic);
                return new Tuple2<LogSort, String>(logSort,diviceId);
            }
        });
        return mapToPairSortRdd;
    }
    public static void main(String[] args) {
        JavaSparkContext sc = CommSparkContext.getsc();
        JavaRDD<String> rdd = sc.textFile("/Users/caizhengjie/IdeaProjects/spark_study01/src/main/java/com/kfk/spark/datas/access.log");
        // rdd map() -> <diviceId,LogInfo(timeStamp,upTraffic,downTraffic)>
        JavaPairRDD<String,LogInfo> mapToPairRdd = mapToPairValues(rdd);
        // mapToPairRdd reduceByKey() -> <diviceId,LogInfo(timeStamp,upTraffic,downTraffic)>
        JavaPairRDD<String,LogInfo> reduceByKeyRdd = reduceByKeyValues(mapToPairRdd);
        // reduceByKeyRdd map() -> <LogSort(timeStamp,upTraffic,downTraffic),diviceId>
        JavaPairRDD<LogSort, String> mapToPairSortRdd = mapToPairSortValues(reduceByKeyRdd);
        // sortByKey
        JavaPairRDD<LogSort,String> sortByKeyValues = mapToPairSortRdd.sortByKey(false);
        // TopN
        List<Tuple2<LogSort,String>> sortKeyList = sortByKeyValues.take(10);
        for (Tuple2<LogSort,String> logSortStringTuple2 : sortKeyList){
            System.out.println(logSortStringTuple2._2 + " : " + logSortStringTuple2._1.getUpTraffic() + " : " + logSortStringTuple2._1.getDownTraffic());
        }
    }
}

运行结果:

efde893d9c254e549f740d9613b3421c : 1036288 : 629025
84da30d2697042ca9a6835f6ccec6024 : 930018 : 737453
94055312e11c464d8bb16f21e4d607c6 : 827278 : 897382
c2a24d73d77d4984a1d88ea3330aa4c5 : 826817 : 943297
6e535645436f4926be1ee6e823dfd9d2 : 806761 : 613670
92f78b79738948bea0d27178bbcc5f3a : 761462 : 567899
1cca6591b6aa4033a190154db54a8087 : 750069 : 696854
f92ecf8e076d44b89f2d070fb1df7197 : 740234 : 779789
e6164ce7a908476a94502303328b26e8 : 722636 : 513737
537ec845bb4b405d9bf13975e4408b41 : 709045 : 642202
相关实践学习
【涂鸦即艺术】基于云应用开发平台CAP部署AI实时生图绘板
【涂鸦即艺术】基于云应用开发平台CAP部署AI实时生图绘板
相关文章
|
6月前
|
Java Go 开发工具
【Java】(9)抽象类、接口、内部的运用与作用分析,枚举类型的使用
抽象类必须使用abstract修饰符来修饰,抽象方法也必须使用abstract修饰符来修饰,抽象方法不能有方法体。抽象类不能被实例化,无法使用new关键字来调用抽象类的构造器创建抽象类的实例。抽象类可以包含成员变量、方法(普通方法和抽象方法都可以)、构造器、初始化块、内部类(接 口、枚举)5种成分。抽象类的构造器不能用于创建实例,主要是用于被其子类调用。抽象类中不一定包含抽象方法,但是有抽象方法的类必定是抽象类abstract static不能同时修饰一个方法。
302 1
|
6月前
|
存储 Java Go
【Java】(3)8种基本数据类型的分析、数据类型转换规则、转义字符的列举
牢记类型转换规则在脑海中将编译和运行两个阶段分开,这是两个不同的阶段,不要弄混!
333 2
|
7月前
|
数据采集 存储 弹性计算
高并发Java爬虫的瓶颈分析与动态线程优化方案
高并发Java爬虫的瓶颈分析与动态线程优化方案
|
8月前
|
安全 Java 编译器
new出来的对象,不一定在堆上?聊聊Java虚拟机的优化技术:逃逸分析
逃逸分析是一种静态程序分析技术,用于判断对象的可见性与生命周期。它帮助即时编译器优化内存使用、降低同步开销。根据对象是否逃逸出方法或线程,分析结果分为未逃逸、方法逃逸和线程逃逸三种。基于分析结果,编译器可进行同步锁消除、标量替换和栈上分配等优化,从而提升程序性能。尽管逃逸分析计算复杂度较高,但其在热点代码中的应用为Java虚拟机带来了显著的优化效果。
261 4
|
8月前
|
机器学习/深度学习 安全 Java
Java 大视界 -- Java 大数据在智能金融反洗钱监测与交易异常分析中的应用(224)
本文探讨 Java 大数据在智能金融反洗钱监测与交易异常分析中的应用,介绍其在数据处理、机器学习建模、实战案例及安全隐私等方面的技术方案与挑战,展现 Java 在金融风控中的强大能力。
|
9月前
|
存储 Java 大数据
Java 大视界 -- Java 大数据在智能家居能源消耗模式分析与节能策略制定中的应用(198)
简介:本文探讨Java大数据技术在智能家居能源消耗分析与节能策略中的应用。通过数据采集、存储与智能分析,构建能耗模型,挖掘用电模式,制定设备调度策略,实现节能目标。结合实际案例,展示Java大数据在智能家居节能中的关键作用。
|
10月前
|
数据采集 搜索推荐 算法
Java 大视界 -- Java 大数据在智能教育学习社区用户互动分析与社区活跃度提升中的应用(274)
本文系统阐述 Java 大数据技术在智能教育学习社区中的深度应用,涵盖数据采集架构、核心分析算法、活跃度提升策略及前沿技术探索,为教育数字化转型提供完整技术解决方案。
|
10月前
|
Java 数据库连接 API
互联网大厂校招 JAVA 工程师笔试题解析及常见考点分析
本文深入解析互联网大厂校招Java工程师笔试题,涵盖基础知识(数据类型、流程控制)、面向对象编程(类与对象、继承与多态)、数据结构与算法(数组、链表、排序算法)、异常处理、集合框架、Java 8+新特性(Lambda表达式、Stream API)、多线程与并发、IO与NIO、数据库操作(JDBC、ORM框架MyBatis)及Spring框架基础(IoC、DI、AOP)。通过技术方案讲解与实例演示,助你掌握核心考点,提升解题能力。
391 2
|
传感器 分布式计算 安全
Java 大视界 -- Java 大数据在智能安防入侵检测系统中的多源数据融合与分析技术(171)
本文围绕 Java 大数据在智能安防入侵检测系统中的应用展开,剖析系统现状与挑战,阐释多源数据融合及分析技术,结合案例与代码给出实操方案,提升入侵检测效能。
|
11月前
|
缓存 安全 Java
【高薪程序员必看】万字长文拆解Java并发编程!(3-1):并发共享问题的解决与分析
活锁:多个线程相互影响对方退出同步代码块的条件而导致线程一直运行的情况。例如,线程1的退出条件是count=5,而线程2和线程3在其代码块中不断地是count进行自增自减的操作,导致线程1永远运行。内存一致性问题:由于JIT即时编译器对缓存的优化和指令重排等造成的内存可见性和有序性问题,可以通过synchronized,volatile,并发集合类等机制来解决。这里的线程安全是指,多个线程调用它们同一个实例的方法时,是线程安全的,但仅仅能保证当前调用的方法是线程安全的,不同方法之间是线程不安全的。
197 0

热门文章

最新文章