尚硅谷电商分析项目之（一）session各范围访问步长、访问时长占比统计

最新推荐文章于 2022-04-09 20:31:37 发布
最新推荐文章于 2022-04-09 20:31:37 发布
阅读量436 收藏
点赞数
分类专栏： 大数据学习
原文链接：http://www.atguigu.com/
版权

session各范围访问步长、访问时长占比统计

简要运行流程：

在这里插入图片描述

user_visit_action表：
在这里插入图片描述
user_info表：
在这里插入图片描述

import java.util.{Date, UUID}

import SessionStat.getSessionRatio
import commons.conf.ConfigurationManager
import commons.constant.Constants
import commons.model.{UserInfo, UserVisitAction}
import commons.utils._
import net.sf.json.JSONObject
import org.apache.spark.SparkConf
import org.apache.spark.rdd.RDD
import org.apache.spark.sql.{SaveMode, SparkSession}

import scala.collection.mutable

/**
  * ClassName:SessionStat02
  * Package:
  * Desciption:
  *
  * @date:2019 /11/29 20:25
  * @author:17611219021 @sina.cn
  */
object SessionStat02 {



  def main(args: Array[String]): Unit = {

    val jsonStr=ConfigurationManager.config.getString(Constants.TASK_PARAMS);
    //获取筛选条件
    val taskParam=JSONObject.fromObject(jsonStr);

    val taskUUID=UUID.randomUUID().toString;

    val sparkConf = new SparkConf().setAppName("session").setMaster("local[4]")
    //创建sparkSession 包含了sparkContext
    val sparkSession = SparkSession.builder().config(sparkConf).enableHiveSupport().getOrCreate()

    //获取原始数据的动作表数据
    val actionRDD: RDD[UserVisitAction] = getOriActionRDD(sparkSession,taskParam)
    //actionRDD.foreach(println(_))
    val sessionId2ActionRDD: RDD[(String, UserVisitAction)] = actionRDD.map(item=>(item.session_id,item))

    val session2GroupRDD: RDD[(String, Iterable[UserVisitAction])] = sessionId2ActionRDD.groupByKey()

    session2GroupRDD.cache()
    val sessionId2FullInfoRDD: RDD[(String, String)] = getSessionFullInfo(sparkSession,session2GroupRDD)
    sessionId2FullInfoRDD.foreach(println(_))
    val sessionAccumulator = new SessionAccumulator

    sparkSession.sparkContext.register(sessionAccumulator)
    val sessionId2FilterRDD = getSessionFilteredRDD(taskParam, sessionId2FullInfoRDD, sessionAccumulator)
    sessionId2FilterRDD.foreach(println(_))
    getSessionRatio(sparkSession, taskUUID, sessionAccumulator.value)




  }

  def getSessionRatio(sparkSession: SparkSession, taskUUID: String, value: mutable.HashMap[String, Int]): Unit = {

    val session_count = value.getOrElse(Constants.SESSION_COUNT, 1).toDouble

    val visit_length_1s_3s = value.getOrElse(Constants.TIME_PERIOD_1s_3s, 0)
    val visit_length_4s_6s = value.getOrElse(Constants.TIME_PERIOD_4s_6s, 0)
    val visit_length_7s_9s = value.getOrElse(Constants.TIME_PERIOD_7s_9s, 0)
    val visit_length_10s_30s = value.getOrElse(Constants.TIME_PERIOD_10s_30s, 0)
    val visit_length_30s_60s = value.getOrElse(Constants.TIME_PERIOD_30s_60s, 0)
    val visit_length_1m_3m = value.getOrElse(Constants.TIME_PERIOD_1m_3m, 0)
    val visit_length_3m_10m = value.getOrElse(Constants.TIME_PERIOD_3m_10m, 0)
    val visit_length_10m_30m = value.getOrElse(Constants.TIME_PERIOD_10m_30m, 0)
    val visit_length_30m = value.getOrElse(Constants.TIME_PERIOD_30m, 0)

    val step_length_1_3 = value.getOrElse(Constants.STEP_PERIOD_1_3, 0)
    val step_length_4_6 = value.getOrElse(Constants.STEP_PERIOD_4_6, 0)
    val step_length_7_9 = value.getOrElse(Constants.STEP_PERIOD_7_9, 0)
    val step_length_10_30 = value.getOrElse(Constants.STEP_PERIOD_10_30, 0)
    val step_length_30_60 = value.getOrElse(Constants.STEP_PERIOD_30_60, 0)
    val step_length_60 = value.getOrElse(Constants.STEP_PERIOD_60, 0)

    val visit_length_1s_3s_ratio = NumberUtils.formatDouble(visit_length_1s_3s / session_count, 2)
    val visit_length_4s_6s_ratio = NumberUtils.formatDouble(visit_length_4s_6s / session_count, 2)
    val visit_length_7s_9s_ratio = NumberUtils.formatDouble(visit_length_7s_9s / session_count, 2)
    val visit_length_10s_30s_ratio = NumberUtils.formatDouble(visit_length_10s_30s / session_count, 2)
    val visit_length_30s_60s_ratio = NumberUtils.formatDouble(visit_length_30s_60s / session_count, 2)
    val visit_length_1m_3m_ratio = NumberUtils.formatDouble(visit_length_1m_3m / session_count, 2)
    val visit_length_3m_10m_ratio = NumberUtils.formatDouble(visit_length_3m_10m / session_count, 2)
    val visit_length_10m_30m_ratio = NumberUtils.formatDouble(visit_length_10m_30m / session_count, 2)
    val visit_length_30m_ratio = NumberUtils.formatDouble(visit_length_30m / session_count, 2)

    val step_length_1_3_ratio = NumberUtils.formatDouble(step_length_1_3 / session_count, 2)
    val step_length_4_6_ratio = NumberUtils.formatDouble(step_length_4_6 / session_count, 2)
    val step_length_7_9_ratio = NumberUtils.formatDouble(step_length_7_9 / session_count, 2)
    val step_length_10_30_ratio = NumberUtils.formatDouble(step_length_10_30 / session_count, 2)
    val step_length_30_60_ratio = NumberUtils.formatDouble(step_length_30_60 / session_count, 2)
    val step_length_60_ratio = NumberUtils.formatDouble(step_length_60 / session_count, 2)

    val stat = SessionAggrStat(taskUUID, session_count.toInt, visit_length_1s_3s_ratio, visit_length_4s_6s_ratio, visit_length_7s_9s_ratio,
      visit_length_10s_30s_ratio, visit_length_30s_60s_ratio, visit_length_1m_3m_ratio,
      visit_length_3m_10m_ratio, visit_length_10m_30m_ratio, visit_length_30m_ratio,
      step_length_1_3_ratio, step_length_4_6_ratio, step_length_7_9_ratio,
      step_length_10_30_ratio, step_length_30_60_ratio, step_length_60_ratio)

    val sessionRatioRDD = sparkSession.sparkContext.makeRDD(Array(stat))
    sessionRatioRDD.foreach(println(_))
    /*import sparkSession.implicits._
    sessionRatioRDD.toDF().write
      .format("jdbc")
      .option("url", ConfigurationManager.config.getString(Constants.JDBC_URL))
      .option("user", ConfigurationManager.config.getString(Constants.JDBC_USER))
      .option("password", ConfigurationManager.config.getString(Constants.JDBC_PASSWORD))
      .option("dbtable", "session_stat_ratio_0416")
      .mode(SaveMode.Append)
      .save()*/
  }

  def getSessionFilteredRDD(taskParam: JSONObject,
                            sessionId2FullInfoRDD: RDD[(String, String)],
                            sessionAccumulator: SessionAccumulator) = {

    val startAge = ParamUtils.getParam(taskParam, Constants.PARAM_START_AGE)
    val endAge = ParamUtils.getParam(taskParam, Constants.PARAM_END_AGE)
    val professionals = ParamUtils.getParam(taskParam, Constants.PARAM_PROFESSIONALS)
    val cities = ParamUtils.getParam(taskParam, Constants.PARAM_CITIES)
    val sex = ParamUtils.getParam(taskParam, Constants.PARAM_SEX)
    val keywords = ParamUtils.getParam(taskParam, Constants.PARAM_KEYWORDS)
    val categoryIds = ParamUtils.getParam(taskParam, Constants.PARAM_CATEGORY_IDS)

    var filterInfo = (if(startAge != null) Constants.PARAM_START_AGE + "=" + startAge + "|" else "") +
      (if (endAge != null) Constants.PARAM_END_AGE + "=" + endAge + "|" else "") +
      (if (professionals != null) Constants.PARAM_PROFESSIONALS + "=" + professionals + "|" else "") +
      (if (cities != null) Constants.PARAM_CITIES + "=" + cities + "|" else "") +
      (if (sex != null) Constants.PARAM_SEX + "=" + sex + "|" else "") +
      (if (keywords != null) Constants.PARAM_KEYWORDS + "=" + keywords + "|" else "") +
      (if (categoryIds != null) Constants.PARAM_CATEGORY_IDS + "=" + categoryIds else "")

    if(filterInfo.endsWith("\\|"))
      filterInfo = filterInfo.substring(0, filterInfo.length - 1)

    sessionId2FullInfoRDD.filter{
      case (sessionId, fullInfo) =>
        var success = true

        if(!ValidUtils.between(fullInfo, Constants.FIELD_AGE, filterInfo, Constants.PARAM_START_AGE, Constants.PARAM_END_AGE)){
          success = false
        }else if(!ValidUtils.in(fullInfo, Constants.FIELD_PROFESSIONAL, filterInfo, Constants.PARAM_PROFESSIONALS)){
          success = false
        }else if(!ValidUtils.in(fullInfo, Constants.FIELD_CITY, filterInfo, Constants.PARAM_CITIES)){
          success = false
        }else if(!ValidUtils.equal(fullInfo, Constants.FIELD_SEX, filterInfo, Constants.PARAM_SEX)){
          success = false
        }else if(!ValidUtils.in(fullInfo, Constants.FIELD_SEARCH_KEYWORDS, filterInfo, Constants.PARAM_KEYWORDS)){
          success = false
        }else if(!ValidUtils.in(fullInfo, Constants.FIELD_CLICK_CATEGORY_IDS, filterInfo, Constants.PARAM_CATEGORY_IDS)){
          success = false
        }

        if(success){
          sessionAccumulator.add(Constants.SESSION_COUNT)

          val visitLength = StringUtils.getFieldFromConcatString(fullInfo, "\\|", Constants.FIELD_VISIT_LENGTH).toLong
          val stepLength = StringUtils.getFieldFromConcatString(fullInfo, "\\|", Constants.FIELD_STEP_LENGTH).toLong

          calculateVisitLength(visitLength, sessionAccumulator)
          calculateStepLength(stepLength, sessionAccumulator)
        }
        success
    }
  }


  def getSessionFullInfo(sparkSession: SparkSession,
                         session2GroupActionRDD: RDD[(String, Iterable[UserVisitAction])]) = {
    // userId2AggrInfoRDD: RDD[(userId, aggrInfo)]
    val userId2AggrInfoRDD = session2GroupActionRDD.map{
      case (sessionId, iterableAction) =>
        var userId = -1L

        var startTime:Date = null
        var endTime:Date = null

        var stepLength = 0

        val searchKeywords = new StringBuffer("")
        val clickCategories = new StringBuffer("")

        for(action <- iterableAction){
          if(userId == -1L){
            userId = action.user_id
          }

          val actionTime = DateUtils.parseTime(action.action_time)
          if(startTime == null || startTime.after(actionTime)){
            startTime = actionTime
          }
          if(endTime == null || endTime.before(actionTime)){
            endTime = actionTime
          }

          val searchKeyword = action.search_keyword
          if(StringUtils.isNotEmpty(searchKeyword) && !searchKeywords.toString.contains(searchKeyword)){
            searchKeywords.append(searchKeyword + ",")
          }

          val clickCategoryId = action.click_category_id
          if(clickCategoryId != -1 && !clickCategories.toString.contains(clickCategoryId)){
            clickCategories.append(clickCategoryId + ",")
          }

          stepLength += 1
        }

        // searchKeywords.toString.substring(0, searchKeywords.toString.length)
        val searchKw = StringUtils.trimComma(searchKeywords.toString)
        val clickCg = StringUtils.trimComma(clickCategories.toString)

        val visitLength = (endTime.getTime - startTime.getTime) / 1000

        val aggrInfo = Constants.FIELD_SESSION_ID + "=" + sessionId + "|" +
          Constants.FIELD_SEARCH_KEYWORDS + "=" + searchKw + "|" +
          Constants.FIELD_CLICK_CATEGORY_IDS + "=" + clickCg + "|" +
          Constants.FIELD_VISIT_LENGTH + "=" + visitLength + "|" +
          Constants.FIELD_STEP_LENGTH + "=" + stepLength + "|" +
          Constants.FIELD_START_TIME + "=" + DateUtils.formatTime(startTime)

        (userId, aggrInfo)
    }

    val sql = "select * from user_info"

    import sparkSession.implicits._
    // userId2InfoRDD:RDD[(userId, UserInfo)]
    val userId2InfoRDD = sparkSession.sql(sql).as[UserInfo].rdd.map(item => (item.user_id, item))

    val sessionId2FullInfoRDD = userId2AggrInfoRDD.join(userId2InfoRDD).map{
      case (userId, (aggrInfo, userInfo)) =>
        val age = userInfo.age
        val professional = userInfo.professional
        val sex = userInfo.sex
        val city = userInfo.city

        val fullInfo = aggrInfo + "|" +
          Constants.FIELD_AGE + "=" + age + "|" +
          Constants.FIELD_PROFESSIONAL + "=" + professional + "|" +
          Constants.FIELD_SEX + "=" + sex + "|" +
          Constants.FIELD_CITY + "=" + city

        val sessionId = StringUtils.getFieldFromConcatString(aggrInfo, "\\|", Constants.FIELD_SESSION_ID)

        (sessionId, fullInfo)
    }

    sessionId2FullInfoRDD
  }


  def getOriActionRDD(sparkSession: SparkSession, taskPram: JSONObject) = {
    val startDate = ParamUtils.getParam(taskPram,Constants.PARAM_START_DATE)
    val endDate = ParamUtils.getParam(taskPram,Constants.PARAM_END_DATE)
    val sql="SELECT * FROM user_visit_action WHERE  date>= '"+startDate+"'AND date <= '"+endDate+"'"
    import sparkSession.implicits._
    sparkSession.sql(sql).as[UserVisitAction].rdd
  }

  def calculateVisitLength(visitLength: Long, sessionStatisticAccumulator: SessionAccumulator) = {
    if(visitLength >= 1 && visitLength <= 3){
      sessionStatisticAccumulator.add(Constants.TIME_PERIOD_1s_3s)
    }else if(visitLength >=4 && visitLength  <= 6){
      sessionStatisticAccumulator.add(Constants.TIME_PERIOD_4s_6s)
    }else if (visitLength >= 7 && visitLength <= 9) {
      sessionStatisticAccumulator.add(Constants.TIME_PERIOD_7s_9s)
    } else if (visitLength >= 10 && visitLength <= 30) {
      sessionStatisticAccumulator.add(Constants.TIME_PERIOD_10s_30s)
    } else if (visitLength > 30 && visitLength <= 60) {
      sessionStatisticAccumulator.add(Constants.TIME_PERIOD_30s_60s)
    } else if (visitLength > 60 && visitLength <= 180) {
      sessionStatisticAccumulator.add(Constants.TIME_PERIOD_1m_3m)
    } else if (visitLength > 180 && visitLength <= 600) {
      sessionStatisticAccumulator.add(Constants.TIME_PERIOD_3m_10m)
    } else if (visitLength > 600 && visitLength <= 1800) {
      sessionStatisticAccumulator.add(Constants.TIME_PERIOD_10m_30m)
    } else if (visitLength > 1800) {
      sessionStatisticAccumulator.add(Constants.TIME_PERIOD_30m)
    }
  }

  def calculateStepLength(stepLength: Long, sessionStatisticAccumulator: SessionAccumulator) = {
    if(stepLength >=1 && stepLength <=3){
      sessionStatisticAccumulator.add(Constants.STEP_PERIOD_1_3)
    }else if (stepLength >= 4 && stepLength <= 6) {
      sessionStatisticAccumulator.add(Constants.STEP_PERIOD_4_6)
    } else if (stepLength >= 7 && stepLength <= 9) {
      sessionStatisticAccumulator.add(Constants.STEP_PERIOD_7_9)
    } else if (stepLength >= 10 && stepLength <= 30) {
      sessionStatisticAccumulator.add(Constants.STEP_PERIOD_10_30)
    } else if (stepLength > 30 && stepLength <= 60) {
      sessionStatisticAccumulator.add(Constants.STEP_PERIOD_30_60)
    } else if (stepLength > 60) {
      sessionStatisticAccumulator.add(Constants.STEP_PERIOD_60)
    }
  }

}


import org.apache.spark.util.AccumulatorV2

import scala.collection.mutable

class SessionAccumulator extends AccumulatorV2[String, mutable.HashMap[String, Int]]{

  val countMap = new mutable.HashMap[String, Int]()

  override def isZero: Boolean = {
    countMap.isEmpty
  }

  override def copy(): AccumulatorV2[String, mutable.HashMap[String, Int]] = {
    val acc = new SessionAccumulator
    acc.countMap ++= this.countMap
    acc
  }

  override def reset(): Unit = {
    countMap.clear()
  }

  override def add(v: String): Unit = {
    if(!this.countMap.contains(v))
      this.countMap += (v -> 0)
    this.countMap.update(v, countMap(v) + 1)
  }

  override def merge(other: AccumulatorV2[String, mutable.HashMap[String, Int]]): Unit = {
    other match {
        // (0 /: (1 to 100))(_+_)
        // (0 /: (1 to 100)){case (int1, !) => int1 + int2}
        // (1 /: 100).foldLeft(0)
        // (this.countMap /: acc.countMap)
      case acc:SessionAccumulator => acc.countMap.foldLeft(this.countMap){
        case (map, (k,v)) => map += (k -> (map.getOrElse(k, 0) + v))
      }
    }
  }

  override def value: mutable.HashMap[String, Int] = {
    this.countMap
  }
}
沉淀技术这十年
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
需求一:各个范围Session步长、访问时长占比统计
zisuu的博客
05-26 1155
做什么? 统计各个范围Session步长、访问时长占比统计 访问时长：session的最早时间与最晚时间之差。 访问步长：session中的action操作个数。 即:统计出符合筛选条件的session中，访问时长在1s3s、4s6s、7s9s、10s30s、30s60s、1m3m、3m10m、10m30m、30m，访问步长在1_3、4_6、…以上各个范围内的各种session的占比 需求分析: 对应的类: case class UserVisitAction(date: String,
spark项目实战：电商分析平台之各个范围Session步长、访问时长占比统计（需求一）
努力努力再努力L
06-03 1020
spark项目实战：电商分析平台之各个范围Session步长、访问时长占比统计（需求一） 项目基本信息，架构，需要一览 各个范围Session步长、访问时长占比统计概述 各个范围Session步长、访问时长占比统计简要运行流程 代码实现 小结 1. 项目基本信息，架构，需要一览 见项目第一篇文章 spark项目实战：电商分析平台之项目概述 代码在github上 初始代码： https:...
31.Spark大型电商项目-用户访问session分析-session聚合统计之自定义Accumulator
someby的博客
03-03 319
目录 介绍 session聚合统计 这种传统的实现方式，缺点 代码 SessionAggrStatAccumulator.java Constants.java 本篇文章将介绍用户访问session分析-session聚合统计之自定义Accumulator。 介绍 session聚合统计 统计出来之前通过条件过滤的session，访问时长在0s~3s的session的数量，占总...
27.session访问时长和步长占比本地测试
Erik_ly的博客
03-24 2492
本文为《Spark大型电商项目实战》 系列文章之一，主要介绍之前实现的访问时长和访问步长所占比例在本地进行测试。
spark 大型项目实战(十八):用户访问session分析(十八) -- session 聚合之重构时长和步长
u012957549的博客
06-04 3503
文章地址：http://www.haha174.top/article/details/256619 源码：https://github.com/haha174/spark-session.git session 聚合统计统计处访问时长和访问步长，各个区间的session 占总session 数据量的比例 首先介绍一下不重构的实现思路 1.actionRDD（前文中介绍的用户数据...
PHP基于cookie与session统计网站访问量并输出显示的方法
10-22
当用户访问网站时，我们可以设置Cookie以跟踪他们是否是首次访问，或者在Session中记录他们的活动。 在给出的代码中，首先通过`fopen()`函数打开名为“count.txt”的文件，然后使用`fgets()`读取文件中的数据，这...
Spark大型项目实战：电商用户行为分析大数据平台开发实战
07-12
1、用户访问session分析,该模块主要是对用户访问session进行统计分析.包括session的聚合指标计算、 按时间比例随机抽取session、获取每天点击、下单和购买排名前10的品类、并获取top10品类的点击量排名前10的session...
大型电商网站session大数据分析实战项目-session-analyzer.zip
最新发布
11-04
大型电商网站session大数据分析实战项目-session-analyzer
使用cookie实现统计访问者登陆次数
10-27
在网站开发中，追踪用户访问次数是一个常见的需求，可以用于分析网站流量、用户活跃度等。本文将详细探讨如何利用Cookie技术来实现这一功能。Cookie是一种小型文本文件，由服务器发送到用户的浏览器，并由浏览器存储...
Session用户行为分析
08-23 739
什么是Session? 如果把产品看成大卖场，那么互联网用户的行为就如同在大卖场扫货的顾客。对卖场来说，顾客从进入商场到离开商场，中间一系列行为购成了一次来访。 同样，对产品来说，用户进入产品到离开产品的一系列行为，就是一次访问。称之为 Session或Visit。 从技术上来说，Session是服务器为了保存用户状态而创建的一个特殊的对象。 用户用浏览器第一次访问产品运行的服务器时，服务器创建一个session对象(该 对象有一个唯一的id,一般称之为sessionId),服..
尚硅谷大数据Hadoop
06-13
尚硅谷的大数据视屏，得资源不易，望大家给点分。。。。。
spark项目实战-电商分析平台
热门推荐
lukabruce的博客
03-25 1万+
第1章 项目概述 电商分析平台是对用户访问电商平台的行为进行分析。 1.1 项目简介   本项目主要讲解一个大型电商网站后台的企业级大数据统计分析平台，该平台以 Spark 为主，对电商网站的流量进行离线和实时的分析。   该大数据分析平台对电商网站的各类用户行为（访问行为、购物行为、广告点击行为等）进行复杂的分析。用统计分析出来的数据，辅助公司中的 PM（产品经理）、数据分析师以及管理人员分析现有产品的状况，并根据用户行为分析结果持续改进产品的设计，以及调整公司的战略和业务。最终达到用大数...
用户访问session分析-按session粒度进行数据聚合
fanyao4144的博客
01-19 1874
思路：之前模拟创建了两张表：user_visit_action 和 user_info 对于user_visit_action表 1. 通过用户传过来的指定日期范围内，从user_visit_action中查询出指定的用户访问数据 变成 actionRDD 2. 将actionRDDw映射成Sessionid ,Row>的格式：sessionid2ActionRDD 3. 对行为数据按S
[2.0.1]代码解读 统计session访问时长占比
Memory of Mr.Snail
07-02 2143
场景[2.0.0]已经对用户session分析模块的统计session访问时长占比功能点的需求分析进行了完美的解说。本文旨在对统计session访问时长占比的代码进行解读，并抽取核心spark知识点单独说明分析1、由action粒度的数据 map 得到 session粒度的数据;进一步group，得到聚合后的session粒度数据 2、join用户表数据得到,包含用户信息的session粒度数据
spark案例：Top10 热门品类
csncd的博客
04-09 2693
数据格式： 数据文件中每行数据采用下划线分隔数据 每一行数据表示用户的一次行为，这个行为只能是 4 种行为的一种 如果搜索关键字为 null,表示数据不是搜索数据 如果点击的品类 ID 和产品 ID 为-1，表示数据不是点击数据 针对于下单行为，一次可以下单多个商品，所以品类 ID 和产品 ID 可以是多个，id 之 间采用逗号分隔，如果本次不是下单行为，则数据采用 null 表示 支付行为和下单行为类似 需求：按照每个品类的点击、下单、支付的量来统计热门品类（先按照点击数排名，靠前的就.
高数基础——步长
weixin_46489969的博客
01-27 9317
1，什么是步长？ 在确定了搜索方向的情况下，讨论搜索步长，希望对下述函数求最小值 直接求解上述函数的最小值的方法叫做精确线搜索（公式解），然而这需要耗费大量的计算，所以我们一般采用非精确线搜索（可能不是最小值，但差不多）inexact line search （1）函数应当有充分的下降 （2）步长不宜太小 【1】STEPS MIGHT BE TOO LONG --- 步长太大，会出现震荡现象 【2】STEPS MIGHT BE TOO SHORT --- 步长太小会走不出去，提前收敛（.
第六阶段-尚硅谷书城案例-购物车模型用Session实现
CXY_C的博客
12-30 315
1.购物车 思路分析： 1.1、购物车模型的创建 1.1.1、创建购物车商品项 CartItem public class CartItem { private Integer id; private String name; private Integer count; private BigDecimal price; private BigDecimal totalPrice; } 1.1.2、创建购物车对象 Cart package com.aig
模拟生成user_visit_action 和user_info 的数据
fanyao4144的博客
01-19 703
import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java.util.Random; import java.util.UUID; import org.apache.spark.api.java.JavaRDD; import org.apache.spark.api.java.
session实现登录时长统计的代码
02-22
我可以提供一些建议：1. 可以使用PHP脚本来记录每个用户的登录时长。2. 可以使用MySQL数据库来存储用户的登录时长数据。3. 可以使用JavaScript代码来收集...5. 可以使用HTML和CSS来创建一个可视化的登录时长统计图表。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值