大数据技术与数仓
大数据技术与数仓

第十篇SparkStreaming手动维护Kafka Offset的几种方式

Spark Streaming No Receivers 方式的createDirectStream 方法不使用接收器，而是创建输入流直接从Kafka 集群节点拉取消息。输入流保证每个消息从Kafka 集群拉取以后只完全转换一次，保证语义一致性。但是当作业发生故障或重启时，要保障从当前的消费位点去处理数据(即Exactly Once语义)，单纯的依靠SparkStreaming本身的机制是不太理想的，生产环境中通常借助手动管理offset的方式来维护kafka的消费位点。本文分享将介绍如何手动管理Kafka的Offset，希望对你有所帮助。本文主要包括以下内容：

  • 如何使用MySQL管理Kafka的Offset
  • 如何使用Redis管理Kafka的OffSet

如何使用MySQL管理Kafka的Offset

我们可以从Spark Streaming 应用程序中编写代码来手动管理Kafka偏移量，偏移量可以从每一批流处理中生成的RDDS偏移量来获取，获取方式为：

KafkaUtils.createDirectStream(...).foreachRDD { rdd =>
// 获取偏移量
val offsetRanges = rdd.asInstanceOf[HasOffsetRanges].offsetRanges
 ...
  }

当获取到偏移量之后，可以将将其保存到外部存储设备中(MySQL、Redis、Zookeeper、HBase等)。

使用案例代码

  • MySQL中用于保存偏移量的表
CREATE TABLE `topic_par_group_offset` (
  `topic` varchar(255) NOT NULL,
  `partition` int(11) NOT NULL,
  `groupid` varchar(255) NOT NULL,
  `offset` bigint(20) DEFAULT NULL,
  PRIMARY KEY (`topic`,`partition`,`groupid`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 ;
  • 常量配置类:ConfigConstants
object ConfigConstants {
  // Kafka配置
  val kafkaBrokers = "kms-2:9092,kms-3:9092,kms-4:9092"
  val groupId = "group_test"
  val kafkaTopics = "test"
  val batchInterval = Seconds(5)
  val streamingStorageLevel = StorageLevel.MEMORY_AND_DISK_SER_2
  val kafkaKeySer = "org.apache.kafka.common.serialization.StringSerializer"
  val kafkaValueSer = "org.apache.kafka.common.serialization.StringSerializer"
  val sparkSerializer = "org.apache.spark.serializer.KryoSerializer"
  val batchSize = 16384
  val lingerMs = 1
  val bufferMemory = 33554432
  // MySQL配置
  val user = "root"
  val password = "123qwe"
  val url = "jdbc:mysql://localhost:3306/kafka_offset"
  val driver = "com.mysql.jdbc.Driver"
  // 检查点配置
  val checkpointDir = "file:///e:/checkpoint"
  val checkpointInterval = Seconds(10)
  // Redis配置
  val redisAddress = "192.168.10.203"
  val redisPort = 6379
  val redisAuth = "123qwe"
  val redisTimeout = 3000
}
  • JDBC连接工具类:JDBCConnPool
object JDBCConnPool {

  val log: Logger = Logger.getLogger(JDBCConnPool.getClass)
  var dataSource: BasicDataSource = null
  /**
    * 创建数据源
    *
    * @return
    */
  def getDataSource(): BasicDataSource = {
    if (dataSource == null) {
      dataSource = new BasicDataSource()
      dataSource.setDriverClassName(ConfigConstants.driver)
      dataSource.setUrl(ConfigConstants.url)
      dataSource.setUsername(ConfigConstants.user)
      dataSource.setPassword(ConfigConstants.password)
      dataSource.setMaxTotal(50)
      dataSource.setInitialSize(3)
      dataSource.setMinIdle(3)
      dataSource.setMaxIdle(10)
      dataSource.setMaxWaitMillis(2 * 10000)
      dataSource.setRemoveAbandonedTimeout(180)
      dataSource.setRemoveAbandonedOnBorrow(true)
      dataSource.setRemoveAbandonedOnMaintenance(true)
      dataSource.setTestOnReturn(true)
      dataSource.setTestOnBorrow(true)
    }
    return dataSource
  }
  /**
    * 释放数据源
    */
  def closeDataSource() = {
    if (dataSource != null) {
      dataSource.close()
    }
  }
  /**
    * 获取数据库连接
    *
    * @return
    */
  def getConnection(): Connection = {
    var conn: Connection = null
    try {
      if (dataSource != null) {
        conn = dataSource.getConnection()
      } else {
        conn = getDataSource().getConnection()
      }
    } catch {
      case e: Exception =>
        log.error(e.getMessage(), e)
    }
    conn
  }

  /**
    * 关闭连接
    */
 def closeConnection (ps:PreparedStatement , conn:Connection ) {
    if (ps != null) {
      try {
        ps.close();
      } catch  {
        case e:Exception =>
          log.error("预编译SQL语句对象PreparedStatement关闭异常！" + e.getMessage(), e);
      }
    }
    if (conn != null) {
      try {
        conn.close();
      } catch  {
        case e:Exception =>
        log.error("关闭连接对象Connection异常！" + e.getMessage(), e);
      }
    }
  }
}
  • Kafka生产者：KafkaProducerTest
object KafkaProducerTest {
  def main(args: Array[String]): Unit = {
    val  props : Properties = new Properties()
    props.put("bootstrap.servers", ConfigConstants.kafkaBrokers)
    props.put("batch.size", ConfigConstants.batchSize.asInstanceOf[Integer])
    props.put("linger.ms", ConfigConstants.lingerMs.asInstanceOf[Integer])
    props.put("buffer.memory", ConfigConstants.bufferMemory.asInstanceOf[Integer])
    props.put("key.serializer",ConfigConstants.kafkaKeySer)
    props.put("value.serializer", ConfigConstants.kafkaValueSer)
   val  producer :  Producer[String, String] = new KafkaProducer[String, String](props)
    val startTime : Long  = System.currentTimeMillis()
    for ( i <- 1 to 100) {
      producer.send(new ProducerRecord[String, String](ConfigConstants.kafkaTopics, "Spark", Integer.toString(i)))
    }
  println("消耗时间：" + (System.currentTimeMillis() - startTime))
    producer.close()
  }
}
  • 读取和保存Offset：

该对象的作用是从外部设备中读取和写入Offset，包括MySQL和Redis

object OffsetReadAndSave {

  /**
    * 从MySQL中获取偏移量
    *
    * @param groupid
    * @param topic
    * @return
    */

  def getOffsetMap(groupid: String, topic: String): mutable.Map[TopicPartition, Long] = {

    val conn = JDBCConnPool.getConnection()
    val selectSql = "select * from topic_par_group_offset where groupid = ? and topic = ?"
    val ppst = conn.prepareStatement(selectSql)
    ppst.setString(1, groupid)
    ppst.setString(2, topic)

    val result: ResultSet = ppst.executeQuery()

    // 主题分区偏移量
    val topicPartitionOffset = mutable.Map[TopicPartition, Long]()

    while (result.next()) {

      val topicPartition: TopicPartition = new TopicPartition(result.getString("topic"), result.getInt("partition"))

      topicPartitionOffset += (topicPartition -> result.getLong("offset"))
    }

    JDBCConnPool.closeConnection(ppst, conn)
    topicPartitionOffset
  }

  /**
    * 从Redis中获取偏移量
    *
    * @param groupid
    * @param topic
    * @return
    */
  def getOffsetFromRedis(groupid: String, topic: String): Map[TopicPartition, Long] = {
    val jedis: Jedis = JedisConnPool.getConnection()
    var offsets = mutable.Map[TopicPartition, Long]()

    val key = s"${topic}_${groupid}"
    val fields : java.util.Map[String, String] = jedis.hgetAll(key)
    for (partition <- JavaConversions.mapAsScalaMap(fields)) {

      offsets.put(new TopicPartition(topic, partition._1.toInt), partition._2.toLong)
    }

    offsets.toMap

  }
  /**
    * 将偏移量写入MySQL
    *
    * @param groupid     消费者组ID
    * @param offsetRange 消息偏移量范围
    */

  def saveOffsetRanges(groupid: String, offsetRange: Array[OffsetRange]) = {

    val conn = JDBCConnPool.getConnection()
    val insertSql = "replace into topic_par_group_offset(`topic`, `partition`, `groupid`, `offset`) values(?,?,?,?)"
    val ppst = conn.prepareStatement(insertSql)

    for (offset <- offsetRange) {

      ppst.setString(1, offset.topic)
      ppst.setInt(2, offset.partition)
      ppst.setString(3, groupid)
      ppst.setLong(4, offset.untilOffset)
      ppst.executeUpdate()
    }
    JDBCConnPool.closeConnection(ppst, conn)

  }
  /**
    * 将偏移量保存到Redis中
    * @param groupid
    * @param offsetRange
    */
  def saveOffsetToRedis(groupid: String, offsetRange: Array[OffsetRange]) = {
    val jedis :Jedis = JedisConnPool.getConnection()
    for(offsetRange<-offsetRange){
      val topic=offsetRange.topic
      val partition=offsetRange.partition
      val offset=offsetRange.untilOffset
      // key为topic_groupid,field为partition，value为offset
      jedis.hset(s"${topic}_${groupid}",partition.toString,offset.toString)
    }
  }
}
  • 业务处理类

该对象是业务处理逻辑，主要是消费Kafka数据，再处理之后进行手动将偏移量保存到MySQL中。在启动程序时，会判断外部存储设备中是否存在偏移量，如果是首次启动则从最初的消费位点消费，如果存在Offset，则从当前的Offset去消费。

观察现象：当首次启动时会从头消费数据，手动停止程序，然后再次启动，会发现会从当前提交的偏移量消费数据。 
object ManualCommitOffset {
  
  def main(args: Array[String]): Unit = {

    val brokers = ConfigConstants.kafkaBrokers
    val groupId = ConfigConstants.groupId
    val topics = ConfigConstants.kafkaTopics
    val batchInterval = ConfigConstants.batchInterval

    val conf = new SparkConf()
      .setAppName(ManualCommitOffset.getClass.getSimpleName)
      .setMaster("local[1]")
      .set("spark.serializer",ConfigConstants.sparkSerializer)

    val ssc = new StreamingContext(conf, batchInterval)
    // 必须开启checkpoint,否则会报错
    ssc.checkpoint(ConfigConstants.checkpointDir)

    ssc.sparkContext.setLogLevel("OFF")
    //使用broker和topic创建direct kafka stream
    val topicSet = topics.split(" ").toSet

    // kafka连接参数
    val kafkaParams = Map[String, Object](
      ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG -> brokers,
      ConsumerConfig.GROUP_ID_CONFIG -> groupId,
      ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG -> classOf[StringDeserializer],
      ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG -> classOf[StringDeserializer],
      ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG -> (false: java.lang.Boolean),
      ConsumerConfig.AUTO_OFFSET_RESET_CONFIG -> "earliest"
    )


    // 从MySQL中读取该主题对应的消费者组的分区偏移量
    val offsetMap = OffsetReadAndSave.getOffsetMap(groupId, topics)
    var inputDStream: InputDStream[ConsumerRecord[String, String]] = null

    //如果MySQL中已经存在了偏移量,则应该从该偏移量处开始消费
    if (offsetMap.size > 0) {
      println("存在偏移量，从该偏移量处进行消费！！")

      inputDStream = KafkaUtils.createDirectStream[String, String](
        ssc,
        LocationStrategies.PreferConsistent,
        ConsumerStrategies.Subscribe[String, String](topicSet, kafkaParams, offsetMap))

    } else {
      //如果MySQL中没有存在了偏移量，从最早开始消费
      inputDStream = KafkaUtils.createDirectStream[String, String](
        ssc,
        LocationStrategies.PreferConsistent,
        ConsumerStrategies.Subscribe[String, String](topicSet, kafkaParams))

    }
    // checkpoint时间间隔，必须是batchInterval的整数倍
    inputDStream.checkpoint(ConfigConstants.checkpointInterval)

    // 保存batch的offset
    var offsetRanges = Array[OffsetRange]()
    // 获取当前DS的消息偏移量
    val transformDS = inputDStream.transform { rdd =>
      // 获取offset
      offsetRanges = rdd.asInstanceOf[HasOffsetRanges].offsetRanges
      rdd
    }


    /**
      * 状态更新函数
      * @param newValues:新的value值
      * @param stateValue：状态值
      * @return
      */
    def updateFunc(newValues: Seq[Int], stateValue: Option[Int]): Option[Int] = {
      var oldvalue = stateValue.getOrElse(0) // 获取状态值
      // 遍历当前数据，并更新状态
      for (newValue <- newValues) {
        oldvalue += newValue
      }
      // 返回最新的状态
      Option(oldvalue)
    }
    // 业务逻辑处理
    // 该示例统计消息key的个数，用于查看是否是从已经提交的偏移量消费数据
    transformDS.map(meg => ("spark", meg.value().toInt)).updateStateByKey(updateFunc).print()

    // 打印偏移量和数据信息，观察输出的结果
    transformDS.foreachRDD { (rdd, time) =>
      // 遍历打印该RDD数据
      rdd.foreach { record =>
        println(s"key=${record.key()},value=${record.value()},partition=${record.partition()},offset=${record.offset()}")
      }
      // 打印消费偏移量信息
      for (o <- offsetRanges) {
        println(s"topic=${o.topic},partition=${o.partition},fromOffset=${o.fromOffset},untilOffset=${o.untilOffset},time=${time}")

      }

      //将偏移量保存到到MySQL中
      OffsetReadAndSave.saveOffsetRanges(groupId, offsetRanges)
    }
    ssc.start()
    ssc.awaitTermination()
  }
}

如何使用Redis管理Kafka的OffSet

  • Redis连接类
object JedisConnPool {
  val config = new JedisPoolConfig
  //最大连接数
  config.setMaxTotal(60)
  //最大空闲连接数
  config.setMaxIdle(10)
  config.setTestOnBorrow(true)

  //服务器ip
  val redisAddress :String = ConfigConstants.redisAddress.toString
  // 端口号
  val redisPort:Int = ConfigConstants.redisPort.toInt
  //访问密码
  val redisAuth :String = ConfigConstants.redisAuth.toString
  //等待可用连接的最大时间
  val redisTimeout:Int = ConfigConstants.redisTimeout.toInt

  val pool = new JedisPool(config,redisAddress,redisPort,redisTimeout,redisAuth)

  def getConnection():Jedis = {
    pool.getResource
  }

}
  • 业务逻辑处理

该对象与上面的基本类似，只不过使用的是Redis来进行存储Offset，存储到Redis的数据类型是Hash，基本格式为：[key field value] -> [ topic_groupid partition offset]，即 key为topic_groupid,field为partition，value为offset。

object ManualCommitOffsetToRedis {

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

    val brokers = ConfigConstants.kafkaBrokers
    val groupId = ConfigConstants.groupId
    val topics = ConfigConstants.kafkaTopics
    val batchInterval = ConfigConstants.batchInterval

    val conf = new SparkConf()
      .setAppName(ManualCommitOffset.getClass.getSimpleName)
      .setMaster("local[1]")
      .set("spark.serializer", ConfigConstants.sparkSerializer)


    val ssc = new StreamingContext(conf, batchInterval)
    // 必须开启checkpoint,否则会报错
    ssc.checkpoint(ConfigConstants.checkpointDir)

    ssc.sparkContext.setLogLevel("OFF")
    //使用broker和topic创建direct kafka stream
    val topicSet = topics.split(" ").toSet

    // kafka连接参数
    val kafkaParams = Map[String, Object](
      ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG -> brokers,
      ConsumerConfig.GROUP_ID_CONFIG -> groupId,
      ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG -> classOf[StringDeserializer],
      ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG -> classOf[StringDeserializer],
      ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG -> (false: java.lang.Boolean),
      ConsumerConfig.AUTO_OFFSET_RESET_CONFIG -> "earliest"
    )


    // 从Redis中读取该主题对应的消费者组的分区偏移量
    val offsetMap = OffsetReadAndSave.getOffsetFromRedis(groupId, topics)
    var inputDStream: InputDStream[ConsumerRecord[String, String]] = null

    //如果Redis中已经存在了偏移量,则应该从该偏移量处开始消费
    if (offsetMap.size > 0) {
      println("存在偏移量，从该偏移量处进行消费！！")

      inputDStream = KafkaUtils.createDirectStream[String, String](
        ssc,
        LocationStrategies.PreferConsistent,
        ConsumerStrategies.Subscribe[String, String](topicSet, kafkaParams, offsetMap))

    } else {
      //如果Redis中没有存在了偏移量，从最早开始消费
      inputDStream = KafkaUtils.createDirectStream[String, String](
        ssc,
        LocationStrategies.PreferConsistent,
        ConsumerStrategies.Subscribe[String, String](topicSet, kafkaParams))

    }
    // checkpoint时间间隔，必须是batchInterval的整数倍
    inputDStream.checkpoint(ConfigConstants.checkpointInterval)

    // 保存batch的offset
    var offsetRanges = Array[OffsetRange]()
    // 获取当前DS的消息偏移量
    val transformDS = inputDStream.transform { rdd =>
      // 获取offset
      offsetRanges = rdd.asInstanceOf[HasOffsetRanges].offsetRanges
      rdd
    }


    /**
      * 状态更新函数
      *
      * @param newValues  :新的value值
      * @param stateValue ：状态值
      * @return
      */
    def updateFunc(newValues: Seq[Int], stateValue: Option[Int]): Option[Int] = {
      var oldvalue = stateValue.getOrElse(0) // 获取状态值
      // 遍历当前数据，并更新状态
      for (newValue <- newValues) {
        oldvalue += newValue
      }
      // 返回最新的状态
      Option(oldvalue)
    }
    // 业务逻辑处理
    // 该示例统计消息key的个数，用于查看是否是从已经提交的偏移量消费数据
    transformDS.map(meg => ("spark", meg.value().toInt)).updateStateByKey(updateFunc).print()

    // 打印偏移量和数据信息，观察输出的结果
    transformDS.foreachRDD { (rdd, time) =>
      // 遍历打印该RDD数据
      rdd.foreach { record =>
        println(s"key=${record.key()},value=${record.value()},partition=${record.partition()},offset=${record.offset()}")
      }
      // 打印消费偏移量信息
      for (o <- offsetRanges) {
        println(s"topic=${o.topic},partition=${o.partition},fromOffset=${o.fromOffset},untilOffset=${o.untilOffset},time=${time}")

      }

      //将偏移量保存到到Redis中
      OffsetReadAndSave.saveOffsetToRedis(groupId, offsetRanges)
    }
    ssc.start()
    ssc.awaitTermination()
  }

}

总结

本文介绍了如何使用外部存储设备来保存Kafka的消费位点，通过详细的代码示例说明了使用MySQL和Redis管理消费位点的方式。当然，外部存储设备很多，用户也可以使用其他的存储设备进行管理Offset，比如Zookeeper和HBase等，其基本处理思路都十分相似。

Spark Streaming No Receivers 方式的createDirectStream 方法不使用接收器，而是创建输入流直接从Kafka 集群节点拉取消息。输入流保证每个消息从Kafka 集群拉取以后只完全转换一次，保证语义一致性。但是当作业发生故障或重启时，要保障从当前的消费位点去处理数据(即Exactly Once语义)，单纯的依靠SparkStreaming本身的机制是不太理想的，生产环境中通常借助手动管理offset的方式来维护kafka的消费位点。本文分享将介绍如何手动管理Kafka的Offset，希望对你有所帮助。本文主要包括以下内容：

  • 如何使用MySQL管理Kafka的Offset
  • 如何使用Redis管理Kafka的OffSet

如何使用MySQL管理Kafka的Offset

我们可以从Spark Streaming 应用程序中编写代码来手动管理Kafka偏移量，偏移量可以从每一批流处理中生成的RDDS偏移量来获取，获取方式为：

KafkaUtils.createDirectStream(...).foreachRDD { rdd =>
// 获取偏移量
val offsetRanges = rdd.asInstanceOf[HasOffsetRanges].offsetRanges
 ...
  }

当获取到偏移量之后，可以将将其保存到外部存储设备中(MySQL、Redis、Zookeeper、HBase等)。

使用案例代码

  • MySQL中用于保存偏移量的表
CREATE TABLE `topic_par_group_offset` (
  `topic` varchar(255) NOT NULL,
  `partition` int(11) NOT NULL,
  `groupid` varchar(255) NOT NULL,
  `offset` bigint(20) DEFAULT NULL,
  PRIMARY KEY (`topic`,`partition`,`groupid`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 ;
  • 常量配置类:ConfigConstants
object ConfigConstants {
  // Kafka配置
  val kafkaBrokers = "kms-2:9092,kms-3:9092,kms-4:9092"
  val groupId = "group_test"
  val kafkaTopics = "test"
  val batchInterval = Seconds(5)
  val streamingStorageLevel = StorageLevel.MEMORY_AND_DISK_SER_2
  val kafkaKeySer = "org.apache.kafka.common.serialization.StringSerializer"
  val kafkaValueSer = "org.apache.kafka.common.serialization.StringSerializer"
  val sparkSerializer = "org.apache.spark.serializer.KryoSerializer"
  val batchSize = 16384
  val lingerMs = 1
  val bufferMemory = 33554432
  // MySQL配置
  val user = "root"
  val password = "123qwe"
  val url = "jdbc:mysql://localhost:3306/kafka_offset"
  val driver = "com.mysql.jdbc.Driver"
  // 检查点配置
  val checkpointDir = "file:///e:/checkpoint"
  val checkpointInterval = Seconds(10)
  // Redis配置
  val redisAddress = "192.168.10.203"
  val redisPort = 6379
  val redisAuth = "123qwe"
  val redisTimeout = 3000
}
  • JDBC连接工具类:JDBCConnPool
object JDBCConnPool {

  val log: Logger = Logger.getLogger(JDBCConnPool.getClass)
  var dataSource: BasicDataSource = null
  /**
    * 创建数据源
    *
    * @return
    */
  def getDataSource(): BasicDataSource = {
    if (dataSource == null) {
      dataSource = new BasicDataSource()
      dataSource.setDriverClassName(ConfigConstants.driver)
      dataSource.setUrl(ConfigConstants.url)
      dataSource.setUsername(ConfigConstants.user)
      dataSource.setPassword(ConfigConstants.password)
      dataSource.setMaxTotal(50)
      dataSource.setInitialSize(3)
      dataSource.setMinIdle(3)
      dataSource.setMaxIdle(10)
      dataSource.setMaxWaitMillis(2 * 10000)
      dataSource.setRemoveAbandonedTimeout(180)
      dataSource.setRemoveAbandonedOnBorrow(true)
      dataSource.setRemoveAbandonedOnMaintenance(true)
      dataSource.setTestOnReturn(true)
      dataSource.setTestOnBorrow(true)
    }
    return dataSource
  }
  /**
    * 释放数据源
    */
  def closeDataSource() = {
    if (dataSource != null) {
      dataSource.close()
    }
  }
  /**
    * 获取数据库连接
    *
    * @return
    */
  def getConnection(): Connection = {
    var conn: Connection = null
    try {
      if (dataSource != null) {
        conn = dataSource.getConnection()
      } else {
        conn = getDataSource().getConnection()
      }
    } catch {
      case e: Exception =>
        log.error(e.getMessage(), e)
    }
    conn
  }

  /**
    * 关闭连接
    */
 def closeConnection (ps:PreparedStatement , conn:Connection ) {
    if (ps != null) {
      try {
        ps.close();
      } catch  {
        case e:Exception =>
          log.error("预编译SQL语句对象PreparedStatement关闭异常！" + e.getMessage(), e);
      }
    }
    if (conn != null) {
      try {
        conn.close();
      } catch  {
        case e:Exception =>
        log.error("关闭连接对象Connection异常！" + e.getMessage(), e);
      }
    }
  }
}
  • Kafka生产者：KafkaProducerTest
object KafkaProducerTest {
  def main(args: Array[String]): Unit = {
    val  props : Properties = new Properties()
    props.put("bootstrap.servers", ConfigConstants.kafkaBrokers)
    props.put("batch.size", ConfigConstants.batchSize.asInstanceOf[Integer])
    props.put("linger.ms", ConfigConstants.lingerMs.asInstanceOf[Integer])
    props.put("buffer.memory", ConfigConstants.bufferMemory.asInstanceOf[Integer])
    props.put("key.serializer",ConfigConstants.kafkaKeySer)
    props.put("value.serializer", ConfigConstants.kafkaValueSer)
   val  producer :  Producer[String, String] = new KafkaProducer[String, String](props)
    val startTime : Long  = System.currentTimeMillis()
    for ( i <- 1 to 100) {
      producer.send(new ProducerRecord[String, String](ConfigConstants.kafkaTopics, "Spark", Integer.toString(i)))
    }
  println("消耗时间：" + (System.currentTimeMillis() - startTime))
    producer.close()
  }
}
  • 读取和保存Offset：

该对象的作用是从外部设备中读取和写入Offset，包括MySQL和Redis

object OffsetReadAndSave {

  /**
    * 从MySQL中获取偏移量
    *
    * @param groupid
    * @param topic
    * @return
    */

  def getOffsetMap(groupid: String, topic: String): mutable.Map[TopicPartition, Long] = {

    val conn = JDBCConnPool.getConnection()
    val selectSql = "select * from topic_par_group_offset where groupid = ? and topic = ?"
    val ppst = conn.prepareStatement(selectSql)
    ppst.setString(1, groupid)
    ppst.setString(2, topic)

    val result: ResultSet = ppst.executeQuery()

    // 主题分区偏移量
    val topicPartitionOffset = mutable.Map[TopicPartition, Long]()

    while (result.next()) {

      val topicPartition: TopicPartition = new TopicPartition(result.getString("topic"), result.getInt("partition"))

      topicPartitionOffset += (topicPartition -> result.getLong("offset"))
    }

    JDBCConnPool.closeConnection(ppst, conn)
    topicPartitionOffset
  }

  /**
    * 从Redis中获取偏移量
    *
    * @param groupid
    * @param topic
    * @return
    */
  def getOffsetFromRedis(groupid: String, topic: String): Map[TopicPartition, Long] = {
    val jedis: Jedis = JedisConnPool.getConnection()
    var offsets = mutable.Map[TopicPartition, Long]()

    val key = s"${topic}_${groupid}"
    val fields : java.util.Map[String, String] = jedis.hgetAll(key)
    for (partition <- JavaConversions.mapAsScalaMap(fields)) {

      offsets.put(new TopicPartition(topic, partition._1.toInt), partition._2.toLong)
    }

    offsets.toMap

  }
  /**
    * 将偏移量写入MySQL
    *
    * @param groupid     消费者组ID
    * @param offsetRange 消息偏移量范围
    */

  def saveOffsetRanges(groupid: String, offsetRange: Array[OffsetRange]) = {

    val conn = JDBCConnPool.getConnection()
    val insertSql = "replace into topic_par_group_offset(`topic`, `partition`, `groupid`, `offset`) values(?,?,?,?)"
    val ppst = conn.prepareStatement(insertSql)

    for (offset <- offsetRange) {

      ppst.setString(1, offset.topic)
      ppst.setInt(2, offset.partition)
      ppst.setString(3, groupid)
      ppst.setLong(4, offset.untilOffset)
      ppst.executeUpdate()
    }
    JDBCConnPool.closeConnection(ppst, conn)

  }
  /**
    * 将偏移量保存到Redis中
    * @param groupid
    * @param offsetRange
    */
  def saveOffsetToRedis(groupid: String, offsetRange: Array[OffsetRange]) = {
    val jedis :Jedis = JedisConnPool.getConnection()
    for(offsetRange<-offsetRange){
      val topic=offsetRange.topic
      val partition=offsetRange.partition
      val offset=offsetRange.untilOffset
      // key为topic_groupid,field为partition，value为offset
      jedis.hset(s"${topic}_${groupid}",partition.toString,offset.toString)
    }
  }
}
  • 业务处理类

该对象是业务处理逻辑，主要是消费Kafka数据，再处理之后进行手动将偏移量保存到MySQL中。在启动程序时，会判断外部存储设备中是否存在偏移量，如果是首次启动则从最初的消费位点消费，如果存在Offset，则从当前的Offset去消费。

观察现象：当首次启动时会从头消费数据，手动停止程序，然后再次启动，会发现会从当前提交的偏移量消费数据。 
object ManualCommitOffset {
  
  def main(args: Array[String]): Unit = {

    val brokers = ConfigConstants.kafkaBrokers
    val groupId = ConfigConstants.groupId
    val topics = ConfigConstants.kafkaTopics
    val batchInterval = ConfigConstants.batchInterval

    val conf = new SparkConf()
      .setAppName(ManualCommitOffset.getClass.getSimpleName)
      .setMaster("local[1]")
      .set("spark.serializer",ConfigConstants.sparkSerializer)

    val ssc = new StreamingContext(conf, batchInterval)
    // 必须开启checkpoint,否则会报错
    ssc.checkpoint(ConfigConstants.checkpointDir)

    ssc.sparkContext.setLogLevel("OFF")
    //使用broker和topic创建direct kafka stream
    val topicSet = topics.split(" ").toSet

    // kafka连接参数
    val kafkaParams = Map[String, Object](
      ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG -> brokers,
      ConsumerConfig.GROUP_ID_CONFIG -> groupId,
      ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG -> classOf[StringDeserializer],
      ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG -> classOf[StringDeserializer],
      ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG -> (false: java.lang.Boolean),
      ConsumerConfig.AUTO_OFFSET_RESET_CONFIG -> "earliest"
    )


    // 从MySQL中读取该主题对应的消费者组的分区偏移量
    val offsetMap = OffsetReadAndSave.getOffsetMap(groupId, topics)
    var inputDStream: InputDStream[ConsumerRecord[String, String]] = null

    //如果MySQL中已经存在了偏移量,则应该从该偏移量处开始消费
    if (offsetMap.size > 0) {
      println("存在偏移量，从该偏移量处进行消费！！")

      inputDStream = KafkaUtils.createDirectStream[String, String](
        ssc,
        LocationStrategies.PreferConsistent,
        ConsumerStrategies.Subscribe[String, String](topicSet, kafkaParams, offsetMap))

    } else {
      //如果MySQL中没有存在了偏移量，从最早开始消费
      inputDStream = KafkaUtils.createDirectStream[String, String](
        ssc,
        LocationStrategies.PreferConsistent,
        ConsumerStrategies.Subscribe[String, String](topicSet, kafkaParams))

    }
    // checkpoint时间间隔，必须是batchInterval的整数倍
    inputDStream.checkpoint(ConfigConstants.checkpointInterval)

    // 保存batch的offset
    var offsetRanges = Array[OffsetRange]()
    // 获取当前DS的消息偏移量
    val transformDS = inputDStream.transform { rdd =>
      // 获取offset
      offsetRanges = rdd.asInstanceOf[HasOffsetRanges].offsetRanges
      rdd
    }


    /**
      * 状态更新函数
      * @param newValues:新的value值
      * @param stateValue：状态值
      * @return
      */
    def updateFunc(newValues: Seq[Int], stateValue: Option[Int]): Option[Int] = {
      var oldvalue = stateValue.getOrElse(0) // 获取状态值
      // 遍历当前数据，并更新状态
      for (newValue <- newValues) {
        oldvalue += newValue
      }
      // 返回最新的状态
      Option(oldvalue)
    }
    // 业务逻辑处理
    // 该示例统计消息key的个数，用于查看是否是从已经提交的偏移量消费数据
    transformDS.map(meg => ("spark", meg.value().toInt)).updateStateByKey(updateFunc).print()

    // 打印偏移量和数据信息，观察输出的结果
    transformDS.foreachRDD { (rdd, time) =>
      // 遍历打印该RDD数据
      rdd.foreach { record =>
        println(s"key=${record.key()},value=${record.value()},partition=${record.partition()},offset=${record.offset()}")
      }
      // 打印消费偏移量信息
      for (o <- offsetRanges) {
        println(s"topic=${o.topic},partition=${o.partition},fromOffset=${o.fromOffset},untilOffset=${o.untilOffset},time=${time}")

      }

      //将偏移量保存到到MySQL中
      OffsetReadAndSave.saveOffsetRanges(groupId, offsetRanges)
    }
    ssc.start()
    ssc.awaitTermination()
  }
}

如何使用Redis管理Kafka的OffSet

  • Redis连接类
object JedisConnPool {
  val config = new JedisPoolConfig
  //最大连接数
  config.setMaxTotal(60)
  //最大空闲连接数
  config.setMaxIdle(10)
  config.setTestOnBorrow(true)

  //服务器ip
  val redisAddress :String = ConfigConstants.redisAddress.toString
  // 端口号
  val redisPort:Int = ConfigConstants.redisPort.toInt
  //访问密码
  val redisAuth :String = ConfigConstants.redisAuth.toString
  //等待可用连接的最大时间
  val redisTimeout:Int = ConfigConstants.redisTimeout.toInt

  val pool = new JedisPool(config,redisAddress,redisPort,redisTimeout,redisAuth)

  def getConnection():Jedis = {
    pool.getResource
  }

}
  • 业务逻辑处理

该对象与上面的基本类似，只不过使用的是Redis来进行存储Offset，存储到Redis的数据类型是Hash，基本格式为：[key field value] -> [ topic_groupid partition offset]，即 key为topic_groupid,field为partition，value为offset。

object ManualCommitOffsetToRedis {

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

    val brokers = ConfigConstants.kafkaBrokers
    val groupId = ConfigConstants.groupId
    val topics = ConfigConstants.kafkaTopics
    val batchInterval = ConfigConstants.batchInterval

    val conf = new SparkConf()
      .setAppName(ManualCommitOffset.getClass.getSimpleName)
      .setMaster("local[1]")
      .set("spark.serializer", ConfigConstants.sparkSerializer)


    val ssc = new StreamingContext(conf, batchInterval)
    // 必须开启checkpoint,否则会报错
    ssc.checkpoint(ConfigConstants.checkpointDir)

    ssc.sparkContext.setLogLevel("OFF")
    //使用broker和topic创建direct kafka stream
    val topicSet = topics.split(" ").toSet

    // kafka连接参数
    val kafkaParams = Map[String, Object](
      ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG -> brokers,
      ConsumerConfig.GROUP_ID_CONFIG -> groupId,
      ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG -> classOf[StringDeserializer],
      ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG -> classOf[StringDeserializer],
      ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG -> (false: java.lang.Boolean),
      ConsumerConfig.AUTO_OFFSET_RESET_CONFIG -> "earliest"
    )


    // 从Redis中读取该主题对应的消费者组的分区偏移量
    val offsetMap = OffsetReadAndSave.getOffsetFromRedis(groupId, topics)
    var inputDStream: InputDStream[ConsumerRecord[String, String]] = null

    //如果Redis中已经存在了偏移量,则应该从该偏移量处开始消费
    if (offsetMap.size > 0) {
      println("存在偏移量，从该偏移量处进行消费！！")

      inputDStream = KafkaUtils.createDirectStream[String, String](
        ssc,
        LocationStrategies.PreferConsistent,
        ConsumerStrategies.Subscribe[String, String](topicSet, kafkaParams, offsetMap))

    } else {
      //如果Redis中没有存在了偏移量，从最早开始消费
      inputDStream = KafkaUtils.createDirectStream[String, String](
        ssc,
        LocationStrategies.PreferConsistent,
        ConsumerStrategies.Subscribe[String, String](topicSet, kafkaParams))

    }
    // checkpoint时间间隔，必须是batchInterval的整数倍
    inputDStream.checkpoint(ConfigConstants.checkpointInterval)

    // 保存batch的offset
    var offsetRanges = Array[OffsetRange]()
    // 获取当前DS的消息偏移量
    val transformDS = inputDStream.transform { rdd =>
      // 获取offset
      offsetRanges = rdd.asInstanceOf[HasOffsetRanges].offsetRanges
      rdd
    }


    /**
      * 状态更新函数
      *
      * @param newValues  :新的value值
      * @param stateValue ：状态值
      * @return
      */
    def updateFunc(newValues: Seq[Int], stateValue: Option[Int]): Option[Int] = {
      var oldvalue = stateValue.getOrElse(0) // 获取状态值
      // 遍历当前数据，并更新状态
      for (newValue <- newValues) {
        oldvalue += newValue
      }
      // 返回最新的状态
      Option(oldvalue)
    }
    // 业务逻辑处理
    // 该示例统计消息key的个数，用于查看是否是从已经提交的偏移量消费数据
    transformDS.map(meg => ("spark", meg.value().toInt)).updateStateByKey(updateFunc).print()

    // 打印偏移量和数据信息，观察输出的结果
    transformDS.foreachRDD { (rdd, time) =>
      // 遍历打印该RDD数据
      rdd.foreach { record =>
        println(s"key=${record.key()},value=${record.value()},partition=${record.partition()},offset=${record.offset()}")
      }
      // 打印消费偏移量信息
      for (o <- offsetRanges) {
        println(s"topic=${o.topic},partition=${o.partition},fromOffset=${o.fromOffset},untilOffset=${o.untilOffset},time=${time}")

      }

      //将偏移量保存到到Redis中
      OffsetReadAndSave.saveOffsetToRedis(groupId, offsetRanges)
    }
    ssc.start()
    ssc.awaitTermination()
  }

}

总结

本文介绍了如何使用外部存储设备来保存Kafka的消费位点，通过详细的代码示例说明了使用MySQL和Redis管理消费位点的方式。当然，外部存储设备很多，用户也可以使用其他的存储设备进行管理Offset，比如Zookeeper和HBase等，其基本处理思路都十分相似。

公主号：大数据技术与数仓

你可能感兴趣的:(spark-streaming)

  • spark-streaming与kafka的整合 王大为学习笔记
    1.概述在2.x中，spark有两个用来与kafka整合的代码，版本代号为0.8和0.10，由于在0.8，kafka有两套消费者api，根据高级api得到了Receiver-basedApproach，根据低级api得到了DirectApproach，而在0.10由于kafka只有一套消费者api了，所以也只有DirectApproach2.DirectApproach由于0.8与0.10的Dir
  • Spark-Streaming+Kafka+mysql实战示例 大数据魔法师 大数据大数据kafkaspark
    文章目录前言一、简介1.Spark-Streaming简介2.Kafka简介二、实战演练1.MySQL数据库部分2.导入依赖3.编写实体类代码4.编写kafka主题管理代码5.编写kafka生产者代码6.编写Spark-Streaming代码7.查看数据库8.代码下载总结前言本文将介绍一个使用SparkStreaming和Kafka进行实时数据处理的示例。通过该示例，您将了解到如何使用SparkS
  • Spark-Streaming KafkaClient 异常解决 大猪大猪
    在使用Spark-Streaming消费Kafka数据的时候，使用如下命令提交到yarnCausedby:java.lang.IllegalArgumentException:Couldnotfinda'KafkaClient'entryintheJAASconfiguration.Systemproperty'java.security.auth.login.config'isnotsetato
  • Flink（一） Flink是什么，特点和优势，应用场景 plenilune-望月 Flink实时计算引擎
    在当前数据量激增的时代，各种业务场景都有大量的业务数据产生，对于这些不断产生的数据应该如何进行有效的处理，成为当下大多数公司所面临的问题。目前比较流行的大数据处理引擎ApacheSpark，基本上已经取代了MapReduce成为当前大数据处理的标准。但对实时数据处理来说，ApacheSpark的Spark-Streaming还有性能改进的空间。对于Spark-Streaming的流计算本质上还是批
  • 【Spark Streaming】（二）Spark Streaming - 实时数据采集 屡傻不改 SparkStreamingSparkStreaming实时数据采集
    导入spark和spark-streaming依赖包org.apache.sparkspark-core_2.112.4.5org.apache.sparkspark-streaming_2.112.4.5案例一：SparkStreaming接受socket数据，实现单词计数WordCountspark版本从本机的7777端口源源不断地收到以换行符分隔的文本数据流，并计算单词个数packagecn
  • 2018-12-25 宇智波_佐助
    spark-streaming消费kafka数据：首次消费截图：手动kill，再次启动：KafkaManager类：packageorg.apache.spark.streaming.kafkaimportkafka.common.TopicAndPartitionimportkafka.message.MessageAndMetadataimportkafka.serializer.Decode
  • 第五篇|Spark-Streaming编程指南(2) 大数据技术与数仓
    第四篇|Spark-Streaming编程指南(1)对SparkStreaming执行机制、Transformations与OutputOperations、SparkStreaming数据源(Sources)、SparkStreaming数据汇(Sinks)进行了讨论。本文将延续上篇内容，主要包括以下内容：有状态的计算基于时间的窗口操作持久化检查点Checkpoint使用DataFrames&S
  • Spark-Streaming之window滑动窗口应用 kwu_ganymede Sparksparkstreaming实时
    Spark-Streaming之window滑动窗口应用，SparkStreaming提供了滑动窗口操作的支持，从而让我们可以对一个滑动窗口内的数据执行计算操作。每次掉落在窗口内的RDD的数据，会被聚合起来执行计算操作，然后生成的RDD，会作为windowDStream的一个RDD。网官图中所示，就是对每三秒钟的数据执行一次滑动窗口计算，这3秒内的3个RDD会被聚合起来进行处理，然后过了两秒钟，又
  • spark-streaming windows netcat 数据萌新
    问题描述SparkStreaming的WordCountCentos下安装nc命令工具netcat(nc)是一个简单而有用的工具，被誉为网络安全界的“瑞士军刀”，不仅可以通过使用TCP或UDP协议的网络连接读写数据，同时还是一个功能强大的网络调试和探测工具，能够建立你需要的几乎所有类型的网络连接。在Linux终端窗口可以直接使用yum工具进行安装：[root@master01spark]#yumi
  • spark-streaming笔记 最美不过你回眸 老师笔记
    SparkStreaming笔记框架的类型：1.离线批处理：mapreduce、hive、SparkCore、Sparksql=》mapreducespark2.SQL的交互式查询：hive、SparkSQL3.流式框架：flume、kafka、SparkStreaming4.实时计算：SparkStreamingStrom（Clojure编写的）/jStrom（java编写的）完全实时的流式数据
  • spark 调度优化 skyjunjun
    1.问题在做spark-streaming的时候最近遇到个特别的问题：每个batch的任务调度执行的时候，某些excutor上调度的任务特别多，其他的excutor上只调度一个image.png甚至200个task只会调度到2个excutor上：image.png2.分析第二个图上看到下面所有的LocalityLevel都为:NODE_LOCAL第一个图上的调度很多的task也是NODE_LOCA
  • 淘宝双11实时数据分析项目报告 阿坨 数据分析kafkasparkhivesocketio
    文章目录环境部署项目主要架构具体步骤流计算步骤python连接kafkaspark-streaming集成kafka编写并运行spark-streaming程序(实时词频统计)编写并运行spark-streaming程序(累加词频统计)在kafka上查看数据统计结果批量计算步骤往hive中导入数据sqoop导出数据到mysql淘宝RFM用户划分Flask-SocketIO实时推送数据Echarts
  • 11 sparkstreaming监控端口信息 张力的程序园
    前面我们已经了解了sparksql的使用，这一节我们将了解spark当中的流处理即spark-streaming。1系统、软件以及前提约束CentOS764工作站作者的机子ip是192.168.100.200，请读者根据自己实际情况设置已完成spark中的DataFrame编程https://www.jianshu.com/nb/37554943xshell为去除权限对操作的影响，所有操作都以ro
  • spark jdbc java_spark之JDBC开发（实战） weixin_39937312 sparkjdbcjava
    一、概述SparkCore、Spark-SQL与Spark-Streaming都是相同的,编写好之后打成jar包使用spark-submit命令提交到集群运行应用$SPARK_HOME/bin#./spark-submit--masterspark://Master01:7077--classMainClassFullName[--files$HIVE_HOME/conf/hive-site.xm
  • kafka consumer 日志疯狂输出 marking the coordinator host:9092 for dead group consumer-test xc丶卡卡 kafkakafka
    最近在调试spark-streaming消费kafka消息时发现日志疯狂输出markingthecoordinatorhost:9092fordeadgroupconsumer-testkafkaserver为集群，连接时使用的是hostname:9092方法去连接，程序也不报错，去kafkaserver当中查询consumer-test组也存在，经过排查发现是由于我的kafka集群某些hostn
  • Spark框架 及 pyspark库 劫径 大数据框架spark大数据
    Spark简介开启sparklocal模式（用于调试代码）集群模式spark-core（RDD）RDD的常用算子transformationvalue型transformationkey-value型transformationactionpersist关闭spark案例SparkSQL（DataFrame）DataFrame简介DataFrame常用算子流式计算Spark-Streaming（基
  • spark-streaming pull方式拉取 flume-1.6.0-cdh5.10.1数据 sunnyboy_4 hadoopsparkflume
    注意：文章末尾提供apache-flume-1.6.0-cdh5.10.1-bin网盘资源连接1、flume配置文件flume-conf-spark-netcat-pull.propertiesa1.sources=r1a1.sinks=k1a1.channels=c1a1.sources.r1.type=netcata1.sources.r1.bind=0.0.0.0a1.sources.r1.
  • Apache Flink 在同程艺龙实时计算平台的研发与应用实践 Apache Flink Flink实时计算大数据大数据实时计算流计算云计算flink
    本文主要介绍ApacheFlink在同程艺龙的应用实践，从当前同程艺龙实时计算平台现状、建设过程、易用性提升、稳定性优化四方面分享了同城艺龙实时计算平台的建设经验，供大家参考。1.背景介绍在2015年初，为了能够采集到用户在PC，APP等平台上的行为轨迹，我们开始开发实时应用。那时可选的技术架构还是比较少的，实时计算框架这块，当时比较主流的有Storm和Spark-streaming。综合考虑实时
  • 让Spark-Streaming在Yarn上长时间运行 数大招疯
    对于长时间运行的SparkStreaming作业，一旦提交到YARN群集便需要永久运行，直到有意停止。任何中断都会引起严重的处理延迟，并可能导致数据丢失或重复。YARN和ApacheSpark都不是为了执行长时间运行的服务而设计的。但是，它们已经成功地满足了近实时数据处理作业的常驻需求。成功并不一定意味着没有技术挑战。这篇博客总结了在安全的YARN集群上，运行一个关键任务且长时间的SparkStr
  • spark实时处理hdfs流数据 gk4030
    项目说明Spark构建一个实时数据处理及展示系统流数据数据处理：scala调用spark-SQL：python如图：Paste_Image.png问题总结1、spark-streaming流处理2、sbt打包3、hdfs小文件（20150701_记，后续补充）后续1、flume、kafka结合spark2、spark处理数据存放到hbase
  • Spark-streaming源码走读（一） 小五_555
    继续一下源码的走读啊，最近看了点别的源代码，发现自己好像一个不会写代码的孩子一样。。。。总觉得自己差了一点什么，但是又说不上来，只能继续努力了。继续上一个部分，start方法里面有个eventLoop,估计是监听一堆事件的，command＋B，看下JobSchedulerEvent有什么类型Event类型eventLoop内部看到这里的第一反应是，里面是用队列来做的，而且长度没限制，当然也没法限制
  • 基于flink sql构建实时数据仓库 愤怒的谜团
    1、需求背景根据目前大数据这一块的发展，已经不局限于离线的分析，挖掘数据潜在的价值，数据的时效性最近几年变得刚需，实时处理的框架有storm，spark-streaming，flink等。想要做到实时数据这个方案可行，需要考虑以下几点：1、状态机制2、精确一次语义3、高吞吐量4、可弹性伸缩的应用5、容错机制，刚好这几点，flink都完美的实现了，并且支持flinksql高级API，减少了开发成本，
  • 大数据-序篇 太菜了-Andy 大数据
    工作多年，回首以前，个人做的技术面宽，而深度不够。而如今失业再次面试，屡屡碰壁，痛定思痛，从基础再次着手，开始巩固定学习.java很核心，但个人一般，javaweb每一段都能自主开发，但不核心scala,python都可以玩，但不够精通大数据中，hive,spark-streaming,spark-sql,kafka都一般般那就大数据领域开始学吧，从mr开始，java/scala/python能满
  • 大数据开发-Spark-Streaming处理数据到mysql 大数据
    前面一篇讲到streamin读取kafka数据加工处理后写到kafka数据，大数据开发-Spark-开发Streaming处理数据&&写入Kafka是针对比如推荐领域，实时标签等场景对于实时处理结果放到mysql也是一种常用方式，假设一些车辆调度的地理位置信息处理后写入到mysql1.说明数据表如下：createdatabasetest;usetest;DROPTABLEIFEXISTScar_g
  • 2021-03-08~09~10~11~12 大数据课程笔记 day47day48day49day50day51 Rich Dad 西行日记lampscipyzkmakefilecrm
    @R星校长大数据技术之Flink第一章初识Flink  在当前数据量激增的时代，各种业务场景都有大量的业务数据产生，对于这些不断产生的数据应该如何进行有效的处理，成为当下大多数公司所面临的问题。目前比较流行的大数据处理引擎ApacheSpark，基本上已经取代了MapReduce成为当前大数据处理的标准。但对实时数据处理来说，ApacheSpark的Spark-Streaming还有性能改进的空间
  • 【转载】Yarn上常驻Spark-Streaming程序调优 大数据技术进阶
    对于长时间运行的SparkStreaming作业，一旦提交到YARN群集便需要永久运行，直到有意停止。任何中断都会引起严重的处理延迟，并可能导致数据丢失或重复。YARN和ApacheSpark都不是为了执行长时间运行的服务而设计的。但是，它们已经成功地满足了近实时数据处理作业的常驻需求。成功并不一定意味着没有技术挑战。这篇博客总结了在安全的YARN集群上，运行一个关键任务且长时间的SparkStr
  • 必备干货 | Hbase简介以及数据结构和表详解 陈敬雷-充电了么-CEO兼CTO 人工智能大数据Hbase人工智能大数据数据库hbase分布式
    注：此文章内容均节选自充电了么创始人，CEO兼CTO陈敬雷先生的新书《分布式机器学习实战》（人工智能科学与技术丛书）【陈敬雷编著】【清华大学出版社】文章目录前言Hbase原理和功能介绍1.Hbase特性2.Hbase的架构核心组件Hbase数据结构和表详解总结前言Hbase经常用来存储实时数据，比如Storm/Flink/Spark-Streaming消费用户行为日志数据进行处理后存储到Hbase
  • spark-streaming-kafka-0-10源码分析 tracy_668
    [TOC]spark-streaming为了匹配0.10以后版本的kafka客户端变化推出了一个目前还是Experimental状态的spark-streaming-kafka-0-10客户端首先看下初始化kafkastream的方法声明，defcreateDirectStream[K,V](ssc:StreamingContext,locationStrategy:LocationStrateg
  • 如何创建 SparkContext，SQLContext，StreamingContext 的几种方式？ 曲健磊 【Spark】
    首先，使用ScalaIDE或IDEA创建Scala的Maven工程。需要用到spark-core，spark-sql，spark-streaming的jar包，pom文件如下：2.1.02.11org.apache.sparkspark-core_${scala.version}${spark.version}org.apache.sparkspark-streaming_${scala.vers
  • Spark streaming基于kafka 以Receiver方式获取数据 原理和案例实战 二府村 Spark梦想
    本博文讲述的内容主要包括：１，SparkStreamingonKafkaReceiver工作原理机制2，SparkStreamingonKafkaReceiver案例实战3，SparkStreamingonKafkaReceiver源码解析一：SparkStreamingonKafkaReceiver简介：1、Spark-Streaming获取kafka数据的两种方式-Receiver与Direc
  • web前段跨域nginx代理配置 刘正强 nginxcmsWeb
    nginx代理配置可参考server部分 server {         listen       80;         server_name  localhost;
  • spring学习笔记 caoyong spring
    一、概述     a>、核心技术 : IOC与AOP b>、开发为什么需要面向接口而不是实现     接口降低一个组件与整个系统的藕合程度，当该组件不满足系统需求时，可以很容易的将该组件从系统中替换掉，而不会对整个系统产生大的影响 c>、面向接口编口编程的难点在于如何对接口进行初始化,(使用工厂设计模式)
  • Eclipse打开workspace提示工作空间不可用 0624chenhong eclipse
    做项目的时候，难免会用到整个团队的代码，或者上一任同事创建的workspace， 1.电脑切换账号后，Eclipse打开时，会提示Eclipse对应的目录锁定，无法访问，根据提示，找到对应目录，G:\eclipse\configuration\org.eclipse.osgi\.manager，其中文件.fileTableLock提示被锁定。 解决办法，删掉.fileTableLock文件，重
  • Javascript 面向对面写法的必要性？ 一炮送你回车库 JavaScript
    现在Javascript面向对象的方式来写页面很流行，什么纯javascript的mvc框架都出来了：ember 这是javascript层的mvc框架哦,不是j2ee的mvc框架   我想说的是，javascript本来就不是一门面向对象的语言，用它写出来的面向对象的程序，本身就有些别扭，很多人提到js的面向对象首先提的是：复用性。那么我请问你写的js里有多少是可以复用的，用fu
  • js array对象的迭代方法 换个号韩国红果果 array
    1.forEach 该方法接受一个函数作为参数， 对数组中的每个元素 使用该函数  return 语句失效 function square(num) { print(num, num * num); } var nums = [1,2,3,4,5,6,7,8,9,10]; nums.forEach(square); 2.every 该方法接受一个返回值为布尔类型
  • 对Hibernate缓存机制的理解 归来朝歌 session一级缓存对象持久化
    在hibernate中session一级缓存机制中，有这么一种情况： 问题描述：我需要new一个对象，对它的几个字段赋值，但是有一些属性并没有进行赋值，然后调用 session.save()方法，在提交事务后，会出现这样的情况： 1：在数据库中有默认属性的字段的值为空 2：既然是持久化对象，为什么在最后对象拿不到默认属性的值？ 通过调试后解决方案如下： 对于问题一，如你在数据库里设置了
  • WebService调用错误合集 darkranger webservice
     Java.Lang.NoClassDefFoundError: Org/Apache/Commons/Discovery/Tools/DiscoverSingleton 调用接口出错， 一个简单的WebService import org.apache.axis.client.Call;import org.apache.axis.client.Service; 首先必不可
  • JSP和Servlet的中文乱码处理 aijuans Java Web
    JSP和Servlet的中文乱码处理 前几天学习了JSP和Servlet中有关中文乱码的一些问题，写成了博客，今天进行更新一下。应该是可以解决日常的乱码问题了。现在作以下总结希望对需要的人有所帮助。我也是刚学，所以有不足之处希望谅解。 一、表单提交时出现乱码： 在进行表单提交的时候，经常提交一些中文，自然就避免不了出现中文乱码的情况，对于表单来说有两种提交方式：get和post提交方式。所以
  • 面试经典六问 atongyeye 工作面试
    题记：因为我不善沟通，所以在面试中经常碰壁，看了网上太多面试宝典，基本上不太靠谱。只好自己总结，并试着根据最近工作情况完成个人答案。以备不时之需。 以下是人事了解应聘者情况的最典型的六个问题： 1 简单自我介绍 关于这个问题，主要为了弄清两件事，一是了解应聘者的背景，二是应聘者将这些背景信息组织成合适语言的能力。 我的回答：(针对技术面试回答，如果是人事面试，可以就掌
  • contentResolver.query()参数详解 百合不是茶 androidquery()详解
    收藏csdn的博客,介绍的比较详细,新手值得一看 1.获取联系人姓名 一个简单的例子，这个函数获取设备上所有的联系人ID和联系人NAME。 [java]  view plain copy   public void fetchAllContacts() {      
  • ora-00054:resource busy and acquire with nowait specified解决方法 bijian1013 oracle数据库killnowait
            当某个数据库用户在数据库中插入、更新、删除一个表的数据，或者增加一个表的主键时或者表的索引时，常常会出现ora-00054:resource busy and acquire with nowait specified这样的错误。主要是因为有事务正在执行（或者事务已经被锁），所有导致执行不成功。 1.下面的语句
  • web 开发乱码 征客丶 springWeb
    以下前端都是 utf-8 字符集编码 一、后台接收 1.1、 get 请求乱码 get 请求中，请求参数在请求头中； 乱码解决方法： a、通过在web 服务器中配置编码格式：tomcat 中，在 Connector 中添加URIEncoding="UTF-8"； 1.2、post 请求乱码 post 请求中，请求参数分两部份， 1.2.1、url？参数，
  • 【Spark十六】： Spark SQL第二部分数据源和注册表的几种方式 bit1129 spark
    Spark SQL数据源和表的Schema case class apply schema parquet json JSON数据源 准备源数据 {"name":"Jack", "age": 12, "addr":{"city":"beijing&
  • JVM学习之:调优总结 -Xms -Xmx -Xmn -Xss BlueSkator -Xss-Xmn-Xms-Xmx
      堆大小设置JVM 中最大堆大小有三方面限制：相关操作系统的数据模型（32-bt还是64-bit）限制；系统的可用虚拟内存限制；系统的可用物理内存限制。32位系统下，一般限制在1.5G~2G；64为操作系统对内存无限制。我在Windows Server 2003 系统，3.5G物理内存，JDK5.0下测试，最大可设置为1478m。典型设置： java -Xmx355
  • jqGrid 各种参数 详解(转帖) BreakingBad jqGrid
      jqGrid 各种参数 详解 分类：  源代码分享  个人随笔请勿参考  解决开发问题 2012-05-09 20:29   84282人阅读   评论(22)   收藏   举报 jquery 服务器 parameters function ajax string  
  • 读《研磨设计模式》-代码笔记-代理模式-Proxy bylijinnan java设计模式
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; /* * 下面
  • 应用升级iOS8中遇到的一些问题 chenhbc ios8升级iOS8
    1、很奇怪的问题，登录界面，有一个判断，如果不存在某个值，则跳转到设置界面，ios8之前的系统都可以正常跳转，iOS8中代码已经执行到下一个界面了，但界面并没有跳转过去，而且这个值如果设置过的话，也是可以正常跳转过去的，这个问题纠结了两天多，之前的判断我是在 -(void)viewWillAppear:(BOOL)animated  中写的，最终的解决办法是把判断写在 -(void
  • 工作流与自组织的关系？ comsci 设计模式工作
      目前的工作流系统中的节点及其相互之间的连接是事先根据管理的实际需要而绘制好的，这种固定的模式在实际的运用中会受到很多限制，特别是节点之间的依存关系是固定的，节点的处理不考虑到流程整体的运行情况，细节和整体间的关系是脱节的，那么我们提出一个新的观点，一个流程是否可以通过节点的自组织运动来自动生成呢？这种流程有什么实际意义呢？   这里有篇论文，摘要是：“针对网格中的服务
  • Oracle11.2新特性之INSERT提示IGNORE_ROW_ON_DUPKEY_INDEX daizj oracle
    insert提示IGNORE_ROW_ON_DUPKEY_INDEX 转自：http://space.itpub.net/18922393/viewspace-752123 在 insert into tablea ...select * from tableb中，如果存在唯一约束，会导致整个insert操作失败。使用IGNORE_ROW_ON_DUPKEY_INDEX提示，会忽略唯一
  • 二叉树:堆 dieslrae 二叉树
        这里说的堆其实是一个完全二叉树,每个节点都不小于自己的子节点,不要跟jvm的堆搞混了.由于是完全二叉树,可以用数组来构建.用数组构建树的规则很简单:     一个节点的父节点下标为: (当前下标 - 1)/2     一个节点的左节点下标为: 当前下标 * 2 + 1   &
  • C语言学习八结构体 dcj3sjt126com c
    为什么需要结构体，看代码 # include <stdio.h> struct Student //定义一个学生类型，里面有age, score, sex, 然后可以定义这个类型的变量 { int age; float score; char sex; } int main(void) { struct Student st = {80, 66.6,
  • centos安装golang dcj3sjt126com centos
    #在国内镜像下载二进制包 wget -c  http://www.golangtc.com/static/go/go1.4.1.linux-amd64.tar.gz tar -C /usr/local -xzf go1.4.1.linux-amd64.tar.gz   #把golang的bin目录加入全局环境变量 cat >>/etc/profile<
  • 10.性能优化-监控-MySQL慢查询 frank1234 性能优化MySQL慢查询
    1.记录慢查询配置 show variables where variable_name like 'slow%' ; --查看默认日志路径 查询结果：--不用的机器可能不同 slow_query_log_file=/var/lib/mysql/centos-slow.log 修改mysqld配置文件：/usr /my.cnf[一般在/etc/my.cnf，本机在/user/my.cn
  • Java父类取得子类类名 happyqing javathis父类子类类名
      在继承关系中，不管父类还是子类，这些类里面的this都代表了最终new出来的那个类的实例对象，所以在父类中你可以用this获取到子类的信息！   package com.urthinker.module.test; import org.junit.Test; abstract class BaseDao<T> { public void
  • Spring3.2新注解@ControllerAdvice jinnianshilongnian @Controller
    @ControllerAdvice，是spring3.2提供的新注解，从名字上可以看出大体意思是控制器增强。让我们先看看@ControllerAdvice的实现：   @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @Documented @Component public @interface Co
  • Java spring mvc多数据源配置 liuxihope spring
    转自：http://www.itpub.net/thread-1906608-1-1.html 1、首先配置两个数据库 <bean id="dataSourceA" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close&quo
  • 第12章 Ajax（下） onestopweb Ajax
    index.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/
  • BW / Universe Mappings blueoxygen BO
      BW Element OLAP Universe Element Cube  Dimension Class Charateristic A class with dimension and detail objects (Detail objects for key and desription) Hi
  • Java开发熟手该当心的11个错误 tomcat_oracle java多线程工作单元测试
    #1、不在属性文件或XML文件中外化配置属性。比如，没有把批处理使用的线程数设置成可在属性文件中配置。你的批处理程序无论在DEV环境中，还是UAT（用户验收 测试）环境中，都可以顺畅无阻地运行，但是一旦部署在PROD 上，把它作为多线程程序处理更大的数据集时，就会抛出IOException，原因可能是JDBC驱动版本不同，也可能是#2中讨论的问题。如果线程数目 可以在属性文件中配置，那么使它成为
  • 推行国产操作系统的优劣 yananay windowslinux国产操作系统
    最近刮起了一股风，就是去“国外货”。从应用程序开始，到基础的系统，数据库，现在已经刮到操作系统了。原因就是“棱镜计划”，使我们终于认识到了国外货的危害，开始重视起了信息安全。操作系统是计算机的灵魂。既然是灵魂，为了信息安全，那我们就自然要使用和推行国货。可是，一味地推行，是否就一定正确呢？ 先说说信息安全。其实从很早以来大家就在讨论信息安全。很多年以前，就据传某世界级的网络设备制造商生产的交
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他