SparkStreaming项目实战,实时计算Pv和Uv

大数据 Spark
日志数据从flume采集过来,落到hdfs供其它离线业务使用,也会sink到kafka,sparkStreaming从kafka拉数据过来,计算pv,uv,uv是用的redis的set集合去重,最后把结果写入mysql数据库,供前端展示使用。

[[403404]]

本文转载自微信公众号「Java大数据与数据仓库」,作者柯少爷。转载本文请联系Java大数据与数据仓库公众号。

最近有个需求,实时统计pv,uv,结果按照date,hour,pv,uv来展示,按天统计,第二天重新统计,当然了实际还需要按照类型字段分类统计pv,uv,比如按照date,hour,pv,uv,type来展示。这里介绍最基本的pv,uv的展示。

id uv pv date hour
1 155599 306053 2018-07-27 18

关于什么是pv,uv,可以参见这篇博客:https://blog.csdn.net/petermsh/article/details/78652246

1、项目流程

日志数据从flume采集过来,落到hdfs供其它离线业务使用,也会sink到kafka,sparkStreaming从kafka拉数据过来,计算pv,uv,uv是用的redis的set集合去重,最后把结果写入mysql数据库,供前端展示使用。

2、具体过程

1)pv的计算

拉取数据有两种方式,基于received和direct方式,这里用direct直拉的方式,用的mapWithState算子保存状态,这个算子与updateStateByKey一样,并且性能更好。当然了实际中数据过来需要经过清洗,过滤,才能使用。

定义一个状态函数

  1. // 实时流量状态更新函数 
  2.   val mapFunction = (datehour:String, pv:Option[Long], state:State[Long]) => { 
  3.     val accuSum = pv.getOrElse(0L) + state.getOption().getOrElse(0L) 
  4.     val output = (datehour,accuSum) 
  5.     state.update(accuSum) 
  6.     output 
  7.   } 

这样就很容易的把pv计算出来了。

2)uv的计算

uv是要全天去重的,每次进来一个batch的数据,如果用原生的reduceByKey或者groupByKey对配置要求太高,在配置较低情况下,我们申请了一个93G的redis用来去重,原理是每进来一条数据,将date作为key,guid加入set集合,20秒刷新一次,也就是将set集合的尺寸取出来,更新一下数据库即可。

  1. helper_data.foreachRDD(rdd => { 
  2.         rdd.foreachPartition(eachPartition => { 
  3.         // 获取redis连接 
  4.           val jedis = getJedis 
  5.           eachPartition.foreach(x => { 
  6.             // 省略若干... 
  7.             jedis.sadd(key,x._2) 
  8.             // 设置存储每天的数据的set过期时间,防止超过redis容量,这样每天的set集合,定期会被自动删除 
  9.             jedis.expire(key,ConfigFactory.rediskeyexists) 
  10.           }) 
  11.           // 关闭连接 
  12.           closeJedis(jedis) 
  13.         }) 
  14.       }) 

3)结果保存到数据库

结果保存到mysql,数据库,10秒刷新一次数据库,前端展示刷新一次,就会重新查询一次数据库,做到实时统计展示pv,uv的目的。

  1. /** 
  2.  * 插入数据 
  3.     * @param data (addTab(datehour)+helperversion) 
  4.     * @param tbName 
  5.     * @param colNames 
  6.     */ 
  7.   def insertHelper(data: DStream[(String, Long)], tbName: String, colNames: String*): Unit = { 
  8.     data.foreachRDD(rdd => { 
  9.       val tmp_rdd = rdd.map(x => x._1.substring(11, 13).toInt) 
  10.       if (!rdd.isEmpty()) { 
  11.         val hour_now = tmp_rdd.max() // 获取当前结果中最大的时间,在数据恢复中可以起作用 
  12.         rdd.foreachPartition(eachPartition => { 
  13.           try { 
  14.             val jedis = getJedis 
  15.             val conn = MysqlPoolUtil.getConnection() 
  16.             conn.setAutoCommit(false
  17.             val stmt = conn.createStatement() 
  18.             eachPartition.foreach(x => { 
  19.               // val sql = .... 
  20.               // 省略若干 
  21.               stmt.addBatch(sql) 
  22.             }) 
  23.             closeJedis(jedis) 
  24.             stmt.executeBatch() // 批量执行sql语句 
  25.             conn.commit() 
  26.             conn.close() 
  27.           } catch { 
  28.             case e: Exception => { 
  29.               logger.error(e) 
  30.               logger2.error(HelperHandle.getClass.getSimpleName + e) 
  31.             } 
  32.           } 
  33.         }) 
  34.       } 
  35.     }) 
  36.   } 
  37.    
  38. // 计算当前时间距离次日零点的时长(毫秒) 
  39. def resetTime = { 
  40.     val now = new Date() 
  41.     val todayEnd = Calendar.getInstance 
  42.     todayEnd.set(Calendar.HOUR_OF_DAY, 23) // Calendar.HOUR 12小时制 
  43.     todayEnd.set(Calendar.MINUTE, 59) 
  44.     todayEnd.set(Calendar.SECOND, 59) 
  45.     todayEnd.set(Calendar.MILLISECOND, 999) 
  46.     todayEnd.getTimeInMillis - now.getTime 
  47.  } 

4)数据容错

流处理消费kafka都会考虑到数据丢失问题,一般可以保存到任何存储系统,包括mysql,hdfs,hbase,redis,zookeeper等到。这里用SparkStreaming自带的checkpoint机制来实现应用重启时数据恢复。

checkpoint

这里采用的是checkpoint机制,在重启或者失败后重启可以直接读取上次没有完成的任务,从kafka对应offset读取数据。

  1. // 初始化配置文件 
  2. ConfigFactory.initConfig() 
  3.  
  4. val conf = new SparkConf().setAppName(ConfigFactory.sparkstreamname) 
  5. conf.set("spark.streaming.stopGracefullyOnShutdown","true"
  6. conf.set("spark.streaming.kafka.maxRatePerPartition",consumeRate) 
  7. conf.set("spark.default.parallelism","24"
  8. val sc = new SparkContext(conf) 
  9.  
  10. while (true){ 
  11.  val ssc = StreamingContext.getOrCreate(ConfigFactory.checkpointdir + DateUtil.getDay(0),getStreamingContext _ ) 
  12.     ssc.start() 
  13.     ssc.awaitTerminationOrTimeout(resetTime) 
  14.     ssc.stop(false,true

checkpoint是每天一个目录,在第二天凌晨定时销毁StreamingContext对象,重新统计计算pv,uv。

注意:ssc.stop(false,true)表示优雅地销毁StreamingContext对象,不能销毁SparkContext对象,ssc.stop(true,true)会停掉SparkContext对象,程序就直接停了。

应用迁移或者程序升级

在这个过程中,我们把应用升级了一下,比如说某个功能写的不够完善,或者有逻辑错误,这时候都是需要修改代码,重新打jar包的,这时候如果把程序停了,新的应用还是会读取老的checkpoint,可能会有两个问题:

执行的还是上一次的程序,因为checkpoint里面也有序列化的代码;

直接执行失败,反序列化失败;

其实有时候,修改代码后不用删除checkpoint也是可以直接生效,经过很多测试,我发现如果对数据的过滤操作导致数据过滤逻辑改变,还有状态操作保存修改,也会导致重启失败,只有删除checkpoint才行,可是实际中一旦删除checkpoint,就会导致上一次未完成的任务和消费kafka的offset丢失,直接导致数据丢失,这种情况下我一般这么做。

这种情况一般是在另外一个集群,或者把checkpoint目录修改下,我们是代码与配置文件分离,所以修改配置文件checkpoint的位置还是很方便的。然后两个程序一起跑,除了checkpoint目录不一样,会重新建,都插入同一个数据库,跑一段时间后,把旧的程序停掉就好。以前看官网这么说,只能记住不能清楚明了,只有自己做时才会想一下办法去保证数据准确。

5)保存offset到mysql

如果保存offset到mysql,就可以将pv, uv和offset作为一条语句保存到mysql,从而可以保证exactly-once语义。

  1. var messages: InputDStream[ConsumerRecord[String, String]] = null 
  2.       if (tpMap.nonEmpty) { 
  3.         messages = KafkaUtils.createDirectStream[String, String]( 
  4.           ssc 
  5.           , LocationStrategies.PreferConsistent 
  6.           , ConsumerStrategies.Subscribe[String, String](topics, kafkaParams, tpMap.toMap) 
  7.         ) 
  8.       } else { 
  9.  
  10.         messages = KafkaUtils.createDirectStream[String, String]( 
  11.           ssc 
  12.           , LocationStrategies.PreferConsistent 
  13.           , ConsumerStrategies.Subscribe[String, String](topics, kafkaParams) 
  14.         ) 
  15.       } 
  16.  
  17.        
  18.       messages.foreachRDD(rdd => { 
  19.           .... 
  20. }) 

从mysql读取offset并且解析:

  1. /** 
  2.     * 从mysql查询offset 
  3.     * 
  4.     * @param tbName 
  5.     * @return 
  6.     */ 
  7.   def getLastOffsets(tbName: String): mutable.HashMap[TopicPartition, Long] = { 
  8.     val sql = s"select offset from ${tbName} where id = (select max(id) from ${tbName})" 
  9.     val conn = MysqlPool.getConnection(config) 
  10.     val psts = conn.prepareStatement(sql) 
  11.     val res = psts.executeQuery() 
  12.     var tpMap: mutable.HashMap[TopicPartition, Long] = mutable.HashMap[TopicPartition, Long]() 
  13.     while (res.next()) { 
  14.       val o = res.getString(1) 
  15.       val jSONArray = JSON.parseArray(o) 
  16.       jSONArray.toArray().foreach(offset => { 
  17.         val json = JSON.parseObject(offset.toString) 
  18.         val topicAndPartition = new TopicPartition(json.getString("topic"), json.getInteger("partition")) 
  19.         tpMap.put(topicAndPartition, json.getLong("untilOffset")) 
  20.       }) 
  21.     } 
  22.     MysqlPool.closeCon(res, psts, conn) 
  23.     tpMap 

6)日志

日志用的log4j2,本地保存一份,ERROR级别的日志会通过邮件发送到手机,如果错误太多也会被邮件轰炸,需要注意。

  1. val logger = LogManager.getLogger(HelperHandle.getClass.getSimpleName) 
  2.   // 邮件level=error日志 
  3.   val logger2 = LogManager.getLogger("email"

 

责任编辑:武晓燕 来源: Java大数据与数据仓库
相关推荐

2021-06-06 13:10:12

FlinkPvUv

2021-11-01 13:11:45

FlinkPvUv

2021-03-10 08:22:47

FlinktopN计算

2022-12-29 09:13:02

实时计算平台

2015-07-31 10:35:18

实时计算

2015-08-31 14:27:52

2015-10-09 13:42:26

hbase实时计算

2019-11-21 09:49:29

架构运维技术

2017-09-26 09:35:22

2019-10-17 09:25:56

Spark StreaPVUV

2016-10-16 13:48:54

多维分析 UVPV

2013-08-04 21:02:59

实时计算存储阿里巴巴和仲

2019-02-18 15:23:21

马蜂窝MESLambda

2021-07-05 10:48:42

大数据实时计算

2021-07-16 10:55:45

数仓一体Flink SQL

2011-10-28 09:05:09

2016-11-02 09:02:56

交通大数据计算

2021-03-10 14:04:10

大数据计算技术

2017-01-15 13:45:20

Docker大数据京东

2020-09-10 17:41:14

ClickHouse数据引擎
点赞
收藏

51CTO技术栈公众号