xiaogp
xiaogp

【offset管理策略】Spark Streaming消费Kafka

摘要：offset管理，Spark Streaming，Kafka

Spark Streaming offset的管理方式

offset的三种管理方式

  • 自动提交offset（彻底放弃使用这种方式吧）：enable.auto.commit=true。一但consumer挂掉，就会导致数据丢失或重复消费。offset不可控。
  • Kafka自身的offset管理：在Kafka 0.10+版本中，offset的默认存储由ZooKeeper移动到了一个自带的topic中，名为__consumer_offsets。Spark Streaming也专门提供了commitAsync() API用于提交offset。需要将参数修改为enable.auto.commit=false。这种offset的管理方式，不会丢失数据，但会出现重复消费。停掉streaming应用程序再次启动后，会再次消费停掉前最后的一个批次数据，应该是由于offset是异步提交的方式导致，offset更新不及时引起的。
  • 自定义offset：可以将offset存放在第方三储中，包括RDBMS、Redis、ZK、ES甚至Kafka中。若消费数据存储在带事务的组件上，则强烈推荐将offset存储在一起，借助事务实现 Exactly-once 语义。

自动提交offset

代码实现，消费JSON数据，消费目标是在控制台打印出JSON数据。

import com.alibaba.fastjson.{JSON, JSONObject}
import org.apache.kafka.clients.consumer.ConsumerConfig
import org.apache.kafka.common.serialization.StringDeserializer
import org.apache.log4j.{Level, Logger}
import org.apache.spark.SparkConf
import org.apache.spark.streaming.kafka010.ConsumerStrategies.Subscribe
import org.apache.spark.streaming.kafka010.{CanCommitOffsets, HasOffsetRanges, KafkaUtils}
import org.apache.spark.streaming.kafka010.LocationStrategies.PreferConsistent
import org.apache.spark.streaming.{Seconds, StreamingContext}

object OffsetAutoCommit {
  Logger.getRootLogger.setLevel(Level.WARN)

  def main(args: Array[String]): Unit = {
    val groupId = args(0)
    // spark配置
    val sparkConf = new SparkConf()
      .setMaster("local[*]")
      .setAppName("OffsetAutoCommit")
      .set("spark.streaming.kafka.maxRatePerPartition", "100")

    // spark streaming上下文
    val ssc = new StreamingContext(sparkConf, Seconds(2))

    // kafka参数
    val kafkaParams = Map[String, Object](
      ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG -> "cloudera01:9092,cloudera02:9092,cloudera03:9092",
      ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG -> classOf[StringDeserializer],
      ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG -> classOf[StringDeserializer],
      ConsumerConfig.AUTO_OFFSET_RESET_CONFIG -> "latest",
      ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG -> (true: java.lang.Boolean),
      ConsumerConfig.GROUP_ID_CONFIG -> groupId
    )

    // 创建DStream
    val kafkaDirectStream = KafkaUtils.createDirectStream(
      ssc,
      PreferConsistent,
      Subscribe[String, String](List("test_gp3"), kafkaParams) // 直接订阅集合
    )

    val saveRdd = kafkaDirectStream.map(x => {
      val jsonObject = JSON.parse(x.value()).asInstanceOf[JSONObject]
      jsonObject.put("partition", x.partition())
      jsonObject.put("offset", x.offset())
      jsonObject
    })

    saveRdd.foreachRDD(rdd => {
      rdd.foreach(x => println(x.toJSONString))
    })

    ssc.start()
    ssc.awaitTermination()
  }
}

修改发送给kafka的数据格式，使得spark程序报错退出，重启spark offset为10的数据丢失，offset为10的数据已经在spark接受到数据时提交，但是消费失败，重启后不会重新消费。

{"partition":0,"offset":9,"id":"1"}
{"partition":1,"offset":9,"id":"0"}
20/10/10 16:53:40 ERROR executor.Executor: Exception in task 0.0 in stage 27.0 (TID 54)
com.alibaba.fastjson.JSONException: not close json text, token : :
    at com.alibaba.fastjson.parser.DefaultJSONParser.close(DefaultJSONParser.java:1427)
    at com.alibaba.fastjson.JSON.parse(JSON.java:156)
    at com.alibaba.fastjson.JSON.parse(JSON.java:143)
    at OffsetAutoCommit$$anonfun$1.apply(OffsetAutoCommit.scala:42)
    at OffsetAutoCommit$$anonfun$1.apply(OffsetAutoCommit.scala:41)
    at scala.collection.Iterator$$anon$11.next(Iterator.scala:409)
    at scala.collection.Iterator$class.foreach(Iterator.scala:893)
    at scala.collection.AbstractIterator.foreach(Iterator.scala:1336)
    at org.apache.spark.rdd.RDD$$anonfun$foreach$1$$anonfun$apply$28.apply(RDD.scala:927)
    at org.apache.spark.rdd.RDD$$anonfun$foreach$1$$anonfun$apply$28.apply(RDD.scala:927)
    at org.apache.spark.SparkContext$$anonfun$runJob$5.apply(SparkContext.scala:2074)
    at org.apache.spark.SparkContext$$anonfun$runJob$5.apply(SparkContext.scala:2074)
    at org.apache.spark.scheduler.ResultTask.runTask(ResultTask.scala:87)
    at org.apache.spark.scheduler.Task.run(Task.scala:109)
    at org.apache.spark.executor.Executor$TaskRunner.run(Executor.scala:381)
    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
    at java.lang.Thread.run(Thread.java:745)
......
[root@cloudera01 MyStreamTest]# bash run_auto_commit.sh 
20/10/10 16:54:10 WARN kafka010.KafkaUtils: overriding enable.auto.commit to false for executor
20/10/10 16:54:10 WARN kafka010.KafkaUtils: overriding auto.offset.reset to none for executor
20/10/10 16:54:10 WARN kafka010.KafkaUtils: overriding executor group.id to spark-executor-OffsetAutoCommit_group_1
20/10/10 16:54:10 WARN kafka010.KafkaUtils: overriding receive.buffer.bytes to 65536 see KAFKA-3135
{"partition":1,"offset":11,"id":"0"}
{"partition":0,"offset":11,"id":"1"}

总结一下auto_commit模式offset管理策略：

  • Spark DStream接受到Kafka数据就算消费完成直接提交offset
  • 如果程序在拉取kafka消息后报错处理失败，再次重启Spark程序不会重复再次消费，数据丢失
  • 在生产者向kafka发送消息的时候，在kafka broker端就会记录每个分区的offset，这个和消费者，消费者没有关系，在生产者和kafka交互的时候就已经产生并且作为依据，也就是说如果更换消费者组，消费的offset是继续累加的而不是从0开始。
    自动提交offset的管理策略.png

    数据4丢失没有被消费成功，因为坏数据4提交了offset，所有重启程序不会一直卡在数据4，可以继续消费，更换消费者组不影响offset累加，不会从头开始。

手动提交，使用自带的API

通过一手的DStream转化为KafkaRDD获得批次的offsets，使用commitAsync API提交offsets，这种使用方式必须将提交offset和数据转化写在同一个foreachRDD代码块中，否则会报错。

import com.alibaba.fastjson.{JSON, JSONObject}
import org.apache.kafka.clients.consumer.ConsumerConfig
import org.apache.kafka.common.serialization.StringDeserializer
import org.apache.log4j.{Level, Logger}
import org.apache.spark.SparkConf
import org.apache.spark.streaming.kafka010.ConsumerStrategies.Subscribe
import org.apache.spark.streaming.kafka010.{CanCommitOffsets, HasOffsetRanges, KafkaUtils}
import org.apache.spark.streaming.kafka010.LocationStrategies.PreferConsistent
import org.apache.spark.streaming.{Seconds, StreamingContext}

object OffsetAPICommit {
  Logger.getRootLogger.setLevel(Level.WARN)

  def main(args: Array[String]): Unit = {
    val groupId = args(0)
    // spark配置
    val sparkConf = new SparkConf()
      .setMaster("local[*]")
      .setAppName("OffsetAPICommit")
      .set("spark.streaming.kafka.maxRatePerPartition", "100")

    // spark streaming上下文
    val ssc = new StreamingContext(sparkConf, Seconds(2))

    // kafka参数
    val kafkaParams = Map[String, Object](
      ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG -> "cloudera01:9092,cloudera02:9092,cloudera03:9092",
      ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG -> classOf[StringDeserializer],
      ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG -> classOf[StringDeserializer],
      ConsumerConfig.AUTO_OFFSET_RESET_CONFIG -> "latest",
      ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG -> (false: java.lang.Boolean),
      ConsumerConfig.GROUP_ID_CONFIG -> groupId
    )

    // 创建DStream
    val kafkaDirectStream = KafkaUtils.createDirectStream(
      ssc,
      PreferConsistent,
      Subscribe[String, String](List("test_gp3"), kafkaParams) // 直接订阅集合
    )

    kafkaDirectStream.foreachRDD(rdd => {
      rdd.foreach(x => {
        val jsonObject = JSON.parse(x.value()).asInstanceOf[JSONObject]
        jsonObject.put("partition", x.partition())
        jsonObject.put("offset", x.offset())
        println(jsonObject)
      })
      //获取当前批次的offset信息
      val offsetRanges = rdd.asInstanceOf[HasOffsetRanges].offsetRanges
      //异步提交offset
      kafkaDirectStream.asInstanceOf[CanCommitOffsets].commitAsync(offsetRanges)
    })

    // 分开来写报错 spark.rdd.MapPartitionsRDD cannot be cast to streaming.kafka010.HasOffsetRange
    // 只有kafkaDirectStream可以转化为kafkaRDD
//    val saveRdd = kafkaDirectStream.map(x => {
//      val jsonObject = JSON.parse(x.value()).asInstanceOf[JSONObject]
//      jsonObject.put("partition", x.partition())
//      jsonObject.put("offset", x.offset())
//      jsonObject
//    })
//
//    saveRdd.foreachRDD(rdd => {
//      //获取当前批次的offset信息
//      val offsetRanges = rdd.asInstanceOf[HasOffsetRanges].offsetRanges
//      rdd.foreach(x => println(x.toJSONString))
//      //异步提交offset
//      saveRdd.asInstanceOf[CanCommitOffsets].commitAsync(offsetRanges)
//    })

    ssc.start()
    ssc.awaitTermination()
  }
}

运行消费成功一条消息，此时修改发送的数据格式使程序报错，再次重启程序消费还是报错，消费一直卡在者条消息，因为offset一直没有提交。

[root@cloudera01 MyStreamTest]# bash run_api_commit.sh 
20/10/12 10:42:30 WARN kafka010.KafkaUtils: overriding enable.auto.commit to false for executor
20/10/12 10:42:30 WARN kafka010.KafkaUtils: overriding auto.offset.reset to none for executor
20/10/12 10:42:30 WARN kafka010.KafkaUtils: overriding executor group.id to spark-executor-offset_api_commit_group_1
20/10/12 10:42:30 WARN kafka010.KafkaUtils: overriding receive.buffer.bytes to 65536 see KAFKA-3135
{"partition":1,"offset":22,"id":"0"}
20/10/12 10:43:16 ERROR executor.Executor: Exception in task 1.0 in stage 22.0 (TID 45)
com.alibaba.fastjson.JSONException: syntax error, position at 0, name id
    at com.alibaba.fastjson.parser.DefaultJSONParser.parseObject(DefaultJSONParser.java:570)
    at com.alibaba.fastjson.parser.DefaultJSONParser.parse(DefaultJSONParser.java:1318)
    at com.alibaba.fastjson.parser.DefaultJSONParser.parse(DefaultJSONParser.java:1284)
    at com.alibaba.fastjson.JSON.parse(JSON.java:152)
    at com.alibaba.fastjson.JSON.parse(JSON.java:143)
    at OffsetAPICommit$$anonfun$main$1$$anonfun$apply$1.apply(OffsetAPICommit.scala:44)
    at OffsetAPICommit$$anonfun$main$1$$anonfun$apply$1.apply(OffsetAPICommit.scala:43)
    at scala.collection.Iterator$class.foreach(Iterator.scala:893)
    at org.apache.spark.streaming.kafka010.KafkaRDDIterator.foreach(KafkaRDD.scala:231)
...
[root@cloudera01 MyStreamTest]# bash run_api_commit.sh 
20/10/12 10:43:23 WARN kafka010.KafkaUtils: overriding enable.auto.commit to false for executor
20/10/12 10:43:23 WARN kafka010.KafkaUtils: overriding auto.offset.reset to none for executor
20/10/12 10:43:23 WARN kafka010.KafkaUtils: overriding executor group.id to spark-executor-offset_api_commit_group_1
20/10/12 10:43:23 WARN kafka010.KafkaUtils: overriding receive.buffer.bytes to 65536 see KAFKA-3135
20/10/12 10:43:29 ERROR executor.Executor: Exception in task 1.0 in stage 0.0 (TID 1)
com.alibaba.fastjson.JSONException: syntax error, position at 0, name id
    at com.alibaba.fastjson.parser.DefaultJSONParser.parseObject(DefaultJSONParser.java:570)
    at com.alibaba.fastjson.parser.DefaultJSONParser.parse(DefaultJSONParser.java:1318)
    at com.alibaba.fastjson.parser.DefaultJSONParser.parse(DefaultJSONParser.java:1284)
    at com.alibaba.fastjson.JSON.parse(JSON.java:152)
    at com.alibaba.fastjson.JSON.parse(JSON.java:143)
    at OffsetAPICommit$$anonfun$main$1$$anonfun$apply$1.apply(OffsetAPICommit.scala:44)
    at OffsetAPICommit$$anonfun$main$1$$anonfun$apply$1.apply(OffsetAPICommit.scala:43)
    at scala.collection.Iterator$class.foreach(Iterator.scala:893)
    at org.apache.spark.streaming.kafka010.KafkaRDDIterator.foreach(KafkaRDD.scala:231)
...

修改启动命令中的消费者组，消费通过,更换消费者组后如果策略是latest程序启动后的新数据可以继续消费，但是之前报错的消息直接丢失。

[root@cloudera01 MyStreamTest]# vim run_api_commit.sh 
[root@cloudera01 MyStreamTest]# bash run_api_commit.sh 
20/10/12 10:43:46 WARN kafka010.KafkaUtils: overriding enable.auto.commit to false for executor
20/10/12 10:43:46 WARN kafka010.KafkaUtils: overriding auto.offset.reset to none for executor
20/10/12 10:43:46 WARN kafka010.KafkaUtils: overriding executor group.id to spark-executor-offset_api_commit_group_2
20/10/12 10:43:46 WARN kafka010.KafkaUtils: overriding receive.buffer.bytes to 65536 see KAFKA-3135
{"partition":1,"offset":24,"id":"0"}
手动使用API提交offset的策略.png

由于手动提交将提交的时间点放在程序真正消费成功而不是拉取到消息，所以一直提交不成功，及时重启也会一直消费这条数据，导致程序一直卡在这条数据报错，此时如果修改消费者组，则从新数据开始，之前的报错的数据不管了，出现数据丢失。

第三方存储offset读写管理策略

从zookeeper读取offset，消费完成再写入zookeeper，这样可以在zk中直接查看和修改offset从而来改变消费位置。创建一个Zk class实现读取，写入，创建Zk节点值，读取broker端offset信息。

import java.util.Properties

import com.alibaba.fastjson.{JSON, JSONObject}
import org.apache.kafka.clients.consumer.ConsumerConfig
import org.apache.kafka.common.serialization.StringDeserializer
import org.apache.log4j.{Level, Logger}
import org.apache.spark.SparkConf
import org.apache.spark.streaming.kafka010.ConsumerStrategies.Subscribe
import org.apache.spark.streaming.kafka010.{ConsumerStrategies, KafkaUtils}
import org.apache.spark.streaming.kafka010.LocationStrategies.PreferConsistent
import org.apache.spark.streaming.{Seconds, StreamingContext}

object OffsetUseZK {
  Logger.getRootLogger.setLevel(Level.WARN)

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

    // spark配置项
    val sparkConf = new SparkConf()
      .setAppName("OffsetUseZK")
      .setMaster("local[*]")
      .set("spark.streaming.kafka.maxRatePerPartition", "100")

    // streaming上下文
    val ssc = new StreamingContext(sparkConf, Seconds(2))

    // 其他配置广播
    val properties: Properties = new Properties()
    properties.setProperty("bootstrap.servers", "cloudera01:9092,cloudera02:9092,cloudera03:9092")
    properties.setProperty("kafka.topic", "test_gp3")
    properties.setProperty("group.id", groupId)
    properties.setProperty("ZK_HOST", "cloudera01,cloudera02,cloudera03")
    val configProperties = ssc.sparkContext.broadcast(properties)

    // kafka参数
    val kafkaParams = Map[String, Object](
      ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG -> "cloudera01:9092,cloudera02:9092,cloudera03:9092",
      ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG -> classOf[StringDeserializer],
      ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG -> classOf[StringDeserializer],
      ConsumerConfig.AUTO_OFFSET_RESET_CONFIG -> "latest",
      ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG -> (true: java.lang.Boolean),
      ConsumerConfig.GROUP_ID_CONFIG -> groupId
    )

    // 获取kafka DStream
    var stry = Subscribe[String, String](List("test_gp3"), kafkaParams)  // 默认直接订阅集合
    val partitionOffsets = ZKUtils.getIns(configProperties.value).getPartitionOffset("/test/monitor/test_gp3/" + groupId)
    //从上次记录的offset开始消费
    if (null != partitionOffsets) {
      println("从上次记录的offset开始消费:", partitionOffsets)
      import scala.collection.JavaConverters._
      stry = ConsumerStrategies.Assign[String, String](partitionOffsets.keySet(), kafkaParams.asJava, partitionOffsets)
    }

    val kafkaDirectStream = KafkaUtils.createDirectStream[String, String](
      ssc,
      PreferConsistent, // 在executor上均匀分布分区
      stry) // 订阅主题集合，kafka参数

    val saveRdd = kafkaDirectStream.map(x => {
      val jsonObject = JSON.parse(x.value()).asInstanceOf[JSONObject]
      jsonObject.put("partition", x.partition())
      jsonObject.put("offset", x.offset())
      jsonObject
    })

    saveRdd.foreachRDD(rdd => {
      rdd.foreach(x => {
        println(x.toJSONString)  // 消费程序
        // offset提交
        ZKUtils.getIns(configProperties.value).setData(
          "/test/monitor/" + configProperties.value.getProperty("kafka.topic") + "/" +
            configProperties.value.getProperty("group.id") + "/" +
            x.getString("partition"),
          x.getString("offset"))}
      )
    })

    ssc.start()
    ssc.awaitTermination()
  }
}

ZKUtils.scala

import org.apache.zookeeper._
import org.apache.zookeeper.common._
import java.util.Properties

import org.apache.kafka.common.TopicPartition
import org.apache.zookeeper.data.Stat
import kafka.api.{OffsetRequest, PartitionMetadata, PartitionOffsetRequestInfo, TopicMetadata, TopicMetadataRequest, TopicMetadataResponse}
import kafka.common.TopicAndPartition
import kafka.consumer.SimpleConsumer

import scala.collection.mutable

class ZKUtils() extends Watcher {
  private var zk: ZooKeeper = _

  private def this(pro: Properties) = {
    this()
    this.zk = new ZooKeeper(pro.getProperty("ZK_HOST"), 20000, this)
  }

  @Override
  def process(event: WatchedEvent) {
    //no watching
  }

  private def createPath(path: String, zk: ZooKeeper): Unit = {
    //创建路径
    PathUtils.validatePath(path)
    var parentPath = path.substring(0, path.indexOf("/", 0) + 1)
    while (parentPath != null && !parentPath.isEmpty) {
      if (zk.exists(parentPath, false) == null) {
        // 同步创建，acl权限完全开放，节点类型持久化节点
        zk.create(parentPath, "".getBytes, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
      }

      // 如果根路径和全路径一致停止创建
      if (parentPath.equals(path)) {
        parentPath = null
      } else {
        // 寻找下一个/作为新根路径
        var idx = path.indexOf("/", parentPath.length() + 1)
        if (-1 == idx) {
          idx = path.length
        }
        parentPath = path.substring(0, idx)
      }
    }
  }

  def setData(path: String, data: String): Stat = {
    if (zk.exists(path, false) == null) {
      createPath(path, zk)
    }
    zk.setData(path, data.getBytes, -1)
  }

  def getData(path: String): String = {
    val stat = zk.exists(path, false)
    if (stat == null) {
      null
    } else {
      new String(zk.getData(path, false, stat))
    }
  }

  /**
   * 使用SimpleConsumer找到leader
   * @param seedBrokers
   * @param topic
   * @return
   */
  private def findLeader(seedBrokers: List[(String, Int)], topic: String): mutable.Map[Int, PartitionMetadata] = {
    val map: mutable.Map[Int, PartitionMetadata] = mutable.Map[Int, PartitionMetadata]()
    for (seed <- seedBrokers) {
      var consumer: SimpleConsumer = null;
      try {
        consumer = new SimpleConsumer(seed._1, seed._2, 100000, 64 * 1024,
          "leaderLookup" + new java.util.Date().getTime());
        val topics: Array[String] = Array[String](topic);
        val req: TopicMetadataRequest = new TopicMetadataRequest(topics, 0);
        val resp: TopicMetadataResponse = consumer.send(req);
        val metaData: Seq[TopicMetadata] = resp.topicsMetadata;
        for (item <- metaData) {
          for (part <- item.partitionsMetadata) {
            map += (part.partitionId -> part)
          }
        }
      } catch {
        case ex: Exception =>
          System.out.println(Thread.currentThread().getName + "[" + "Error communicating with Broker [" + seed + "] to find Leader for [" + topic
            + ", ] Reason: " + ex);
      } finally {
        if (consumer != null)
          consumer.close();
      }
    }
    println("map", map)  // Map("分区" -> 分区元数据)
    map
  }

  def getTopicOffsets(topic: String, bootstrap: String, where: String): java.util.Map[TopicPartition, java.lang.Long] = {
    val clientId = ""
    var brokers = List[(String, Int)]()
    var hostAry: Array[String] = bootstrap.split(",");
    if (hostAry == null) {
      hostAry = new Array[String](1)
      hostAry(0) = bootstrap;
    }

    for (host <- hostAry) {
      val hostinfo: Array[String] = host.split(":")
      if (hostinfo == null) {
        if (host != null && !host.isEmpty()) {
          brokers = brokers.+:((host, 9092))
        }
      } else {
        if (hostinfo(0).length > 0 && hostinfo(1).length > 0) {
          brokers = brokers.+:((hostinfo(0), Integer.parseInt(hostinfo(1))))
        }
      }
    }
    println("brokers: ", brokers)  // List((cloudera03,9092), (cloudera02,9092), (cloudera01,9092))

    val metas = findLeader(brokers, topic)
    val ret = new java.util.HashMap[TopicPartition, java.lang.Long]()
    //遍历每个主分区
    metas.keys.foreach(f => {
      val meta = metas(f)
      println("查看meta.leader： ", meta.leader)  // Some(BrokerEndPoint(79,cloudera03,9092)))
      meta.leader match {
        case Some(leader) => {
          var consumer: SimpleConsumer = null
          try {
            consumer = new SimpleConsumer(leader.host, leader.port, 10000, 100000, clientId)
            val topicAndPartition = TopicAndPartition(topic, f)
            var request: OffsetRequest = null
            if (where.equals("earliest")) {
              request = OffsetRequest(Map(topicAndPartition -> PartitionOffsetRequestInfo(OffsetRequest.EarliestTime, 1)))
            } else if (where.equals("latest")) {
              request = OffsetRequest(Map(topicAndPartition -> PartitionOffsetRequestInfo(OffsetRequest.LatestTime, 1)))
            }
            val offsets = consumer.getOffsetsBefore(request).partitionErrorAndOffsets(topicAndPartition).offsets
            println("offsets: ", offsets.head)
            ret.put(new TopicPartition(topic, f), new java.lang.Long(offsets.head))
          } catch {
            case ex: Exception => {
              ex.printStackTrace()
            }
          } finally {
            consumer.close
          }
        }
        case None => {
          System.err.println(Thread.currentThread().getName + "[" + "Error: partition %d does not exist".format(f))
        }
      }
    })
    println("findLeader ret: ", ret)
    ret
  }

  /**
   * 获得每个分区的当下需要消费的offset
   * @param path
   * @return
   */
  def getPartitionOffset(path: String): java.util.Map[TopicPartition, java.lang.Long] = {
    if (zk.exists(path, false) == null) {
      null
    } else {
      val children: java.util.List[java.lang.String] = zk.getChildren(path, false)
      println("获取路径的子节点信息: ", children)

      // 遍历zk上每个分区的offset值
      if (children != null && children.size() > 0) {
        val topic = path.split("/")(3)
        println("获取主题: ", topic)

        val earliestOffsets = getTopicOffsets(
          topic,
          "cloudera01:9092,cloudera02:9092,cloudera03:9092",
          "earliest")
        println("获取最早的offset: ", earliestOffsets)

        val latestOffsets = getTopicOffsets(
          topic,
          "cloudera01:9092,cloudera02:9092,cloudera03:9092",
          "latest")
        println("获取最新的offset: ", latestOffsets)

        // 初始化一个Map存储所有分区的offset
        val ret = new java.util.HashMap[TopicPartition, java.lang.Long]()
        // 遍历节点值，获取分区信息
        for (i <- 0 until children.size) {
          val keyObj = new TopicPartition(topic, children.get(i).toInt)
          // 再往下一层节点，获取节点值+1为新的要拉取的offset
          var offset = new java.lang.Long(getData(path + "/" + children.get(i)).toLong + 1)

          // 如果zk节点的offset比最早offset还小，修正到最早offset
          if (offset.longValue() < earliestOffsets.get(keyObj).longValue()) {
            offset = earliestOffsets.get(keyObj)
          } else if (offset.longValue() > latestOffsets.get(keyObj).longValue()) {
            // 如果zk节点的offset比最新offset大，修正到最新offset
            offset = latestOffsets.get(keyObj)
          }
          ret.put(keyObj, offset)
          println("ret: ", ret)
          //把存在的都删掉
          earliestOffsets.remove(keyObj)
        }

        //把不存在的 再添加进去
        ret.putAll(earliestOffsets)
        ret
      } else {
        null
      }
    }
  }
}


object ZKUtils {
  private var zkUtils: ZKUtils = _

  def getIns(prop: Properties): ZKUtils = {
    this.synchronized {
      if (zkUtils == null) {
        zkUtils = new ZKUtils(prop)
      }
      zkUtils
    }
  }

运行程序消费，第一次在Zk读取不到offset节点值直接订阅消息，终端程序重启，从上次记录的offset开始消费，使用Assign指定分区和offset进行消费。

[root@cloudera01 MyStreamTest]# bash run_use_zk.sh 
20/10/12 11:55:25 WARN kafka010.KafkaUtils: overriding enable.auto.commit to false for executor
20/10/12 11:55:25 WARN kafka010.KafkaUtils: overriding auto.offset.reset to none for executor
20/10/12 11:55:25 WARN kafka010.KafkaUtils: overriding executor group.id to spark-executor-offset_use_zk_1
20/10/12 11:55:25 WARN kafka010.KafkaUtils: overriding receive.buffer.bytes to 65536 see KAFKA-3135
{"partition":1,"offset":32,"id":"0"}
{"partition":1,"offset":33,"id":"0"}
{"partition":1,"offset":34,"id":"0"}
{"partition":1,"offset":35,"id":"0"}
{"partition":0,"offset":28,"id":"0"}
^C[root@cloudera01 MyStreamTest]# bash run_use_zk.sh 
(从上次记录的offset开始消费:,{test_gp3-0=29, test_gp3-1=36})
20/10/12 11:58:27 WARN kafka010.KafkaUtils: overriding enable.auto.commit to false for executor
20/10/12 11:58:27 WARN kafka010.KafkaUtils: overriding auto.offset.reset to none for executor
20/10/12 11:58:27 WARN kafka010.KafkaUtils: overriding executor group.id to spark-executor-offset_use_zk_1
20/10/12 11:58:27 WARN kafka010.KafkaUtils: overriding receive.buffer.bytes to 65536 see KAFKA-3135

修改发送数据的格式让程序报错，重启之后一直卡在报错的数据的offset，此时手动修改Zk的节点值向后加1，则能顺利消费

[zk: localhost:2181(CONNECTED) 27] set /test/monitor/test_gp3/offset_use_zk_1/0 30
cZxid = 0x3d000e28ff
ctime = Mon Oct 12 11:57:50 CST 2020
mZxid = 0x3d000e344a
mtime = Mon Oct 12 14:08:10 CST 2020
pZxid = 0x3d000e28ff
cversion = 0
dataVersion = 2
aclVersion = 0
ephemeralOwner = 0x0
dataLength = 2
numChildren = 0
[zk: localhost:2181(CONNECTED) 28] set /test/monitor/test_gp3/offset_use_zk_1/1 36
cZxid = 0x3d000e28cf
ctime = Mon Oct 12 11:56:02 CST 2020
mZxid = 0x3d000e344b
mtime = Mon Oct 12 14:08:18 CST 2020
pZxid = 0x3d000e28cf
cversion = 0
dataVersion = 5
aclVersion = 0
ephemeralOwner = 0x0
dataLength = 2
numChildren = 0

修改回正确数据格式，读取调整后的Zk节点offset值继续消费

[root@cloudera01 MyStreamTest]# bash run_use_zk.sh 
(从上次记录的offset开始消费:,{test_gp3-0=31, test_gp3-1=36})
20/10/12 14:08:41 WARN kafka010.KafkaUtils: overriding enable.auto.commit to false for executor
20/10/12 14:08:41 WARN kafka010.KafkaUtils: overriding auto.offset.reset to none for executor
20/10/12 14:08:41 WARN kafka010.KafkaUtils: overriding executor group.id to spark-executor-offset_use_zk_1
20/10/12 14:08:41 WARN kafka010.KafkaUtils: overriding receive.buffer.bytes to 65536 see KAFKA-3135
{"partition":1,"offset":36,"id":"0"}

zookeeper管理offset的策略.png

和commitAsync一样不消费成功不提交offset，可以手动修改zk的offset节点值控制消费位移。

你可能感兴趣的:(【offset管理策略】Spark Streaming消费Kafka)

  • 关于沟通这件事，项目经理不需要每次都面对面进行 流程大师兄
    很多项目经理都会遇到这样的问题，项目中由于事情太多，根本没有足够的时间去召开会议，那在这种情况下如何去有效地管理项目中的利益相关者？当然，不建议电子邮件也不需要开会的话，建议可以采取下面几种方式来形成有效的沟通，这几种方式可以帮助你努力的通过各种办法来保持和各方面的联系。项目经理首先要问自己几个问题，项目中哪些利益相关者是必须要进行沟通的？可以列出项目中所有的利益相关者清单，同时也整理出项目中哪些
  • 微服务下功能权限与数据权限的设计与实现 nbsaas-boot 微服务java架构
    在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
  • 学点心理知识，呵护孩子健康 静候花开_7090
    昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
  • 店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码 说私域 人工智能小程序
    摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
  • 消息中间件有哪些常见类型 xmh-sxh-1314 java
    消息中间件根据其设计理念和用途，可以大致分为以下几种常见类型：点对点消息队列（Point-to-PointMessagingQueues）：在这种模型中，消息被发送到特定的队列中，消费者从队列中取出并处理消息。队列中的消息只能被一个消费者消费，消费后即被删除。常见的实现包括IBM的MQSeries、RabbitMQ的部分使用场景等。适用于任务分发、负载均衡等场景。发布/订阅消息模型（Pub/Sub
  • 直返最高等级与直返APP：无需邀请码的返利新体验 古楼
    随着互联网的普及和电商的兴起，直返模式逐渐成为一种流行的商业模式。在这种模式下，消费者通过购买产品或服务，获得一定的返利，并可以分享给更多的人。其中，直返最高等级和直返APP是直返模式中的重要概念和工具。本文将详细介绍直返最高等级的概念、直返APP的使用以及与邀请码的关系。【高省】APP（高佣金领导者）是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几百万篇报道，运行三年，稳定可靠。高省APP，
  • 如何部分格式化提示模板:LangChain中的高级技巧 nseejrukjhad langchainjava服务器python
    标题:如何部分格式化提示模板:LangChain中的高级技巧内容:如何部分格式化提示模板:LangChain中的高级技巧引言在使用大型语言模型(LLM)时,提示工程是一个关键环节。LangChain提供了强大的提示模板功能,让我们能更灵活地构建和管理提示。本文将介绍LangChain中一个高级特性-部分格式化提示模板,这个技巧可以让你的提示管理更加高效和灵活。什么是部分格式化提示模板?部分格式化提
  • GitHub上克隆项目 bigbig猩猩 github
    从GitHub上克隆项目是一个简单且直接的过程，它允许你将远程仓库中的项目复制到你的本地计算机上，以便进行进一步的开发、测试或学习。以下是一个详细的步骤指南，帮助你从GitHub上克隆项目。一、准备工作1.安装Git在克隆GitHub项目之前，你需要在你的计算机上安装Git工具。Git是一个开源的分布式版本控制系统，用于跟踪和管理代码变更。你可以从Git的官方网站（https://git-scm.
  • 人生的每一步路都算数 sheli
    如果你想打工，一直靠打工赚钱，那你就会不断的希望自己变得更专业，不断的希望能够获得更好的工作机会，升职加薪。如果你的目标志不在此，而是拥有自己的企业，那你的选择就会出现差别。在认真打工的人眼里，会“不务正业”，会总是选择不同岗位，甚至放弃高薪机会。但是这背后都是有更加长远的规划。成功富人所必需的管理技能包括：1．对现金流的管理。2．对系统的管理。3．对人员的管理。所以，在没有获得这些能力之前，只要
  • Kafka 消息丢失如何处理？ 架构文摘JGWZ 学习
    今天给大家分享一个在面试中经常遇到的问题：Kafka消息丢失该如何处理？这个问题啊，看似简单，其实里面藏着很多“套路”。来，咱们先讲一个面试的“真实”案例。面试官问：“Kafka消息丢失如何处理？”小明一听，反问：“你是怎么发现消息丢失了？”面试官顿时一愣，沉默了片刻后，可能有点不耐烦，说道：“这个你不用管，反正现在发现消息丢失了，你就说如何处理。”小明一头雾水：“问题是都不知道怎么丢的，处理起来
  • 冬天短期的暴利小生意有哪些？那些小生意适合新手做？ 一起高省
    短期生意不失为创业的一个商机，不过短期生意的商机是转瞬即逝的，而且这类生意也很难作为长期的生意去做，那冬天短期暴利小生意查看更多关于短期暴利小生意的文章有哪些呢?给大家先推荐一个2023年风口项目吧，真很不错的项目，全程零投资，当做副业来做真的很稳定，不管你什么阶层的人，或多或少都网购吧？你们知道网购是可以拿提成，拿返利，拿分佣的吗？你们知道很多优惠券群里面，天天群主和管理发一些商品吗？他们其实在
  • 【华为OD技术面试真题 - 技术面】- python八股文真题题库（4) 算法大师 华为od面试python
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选**1.Python中的`with`**用途和功能自动资源管理示例：文件操作上下文管理协议示例代码工作流程解析优点2.\_\_new\_\_和**\_\_init\_\_**区别__new____init__区别总结3.**切片（Slicing）操作**基本切片语法
  • 01-Git初识 Meereen Gitgit
    01-Git初识概念：一个免费开源，分布式的代码版本控制系统，帮助开发团队维护代码作用：记录代码内容。切换代码版本，多人开发时高效合并代码内容如何学：个人本机使用：Git基础命令和概念多人共享使用：团队开发同一个项目的代码版本管理Git配置用户信息配置：用户名和邮箱，应用在每次提交代码版本时表明自己的身份命令：查看git版本号git-v配置用户名gitconfig--globaluser.name
  • 果然只有离职的时候，才有人敢说真话！ return2ok
    今天公司出了神贴。今天中午吃饭，同事问我看了论坛上的神贴了吗？什么帖子？我问。同事显得很惊讶，你居然没看，现在那个帖子可能会成为年度最佳帖子。这么厉害？我等不及了，饭没吃完就快速的奔向办公室，打开公司论坛，我要一睹这个帖子的神奇。写这帖子的童鞋胆儿真肥。这哪里是一个帖子，这是很多个帖子，组成了一个系列。某人从公司文化、管理、人事、项目管理等多个方面分析了公司的概况，并抨击了公司的各种弊端，并提出了
  • nosql数据库技术与应用知识点 皆过客，揽星河 NoSQLnosql数据库大数据数据分析数据结构非关系型数据库
    Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
  • 如何选择最适合你的项目研发管理软件？TAPD卓越版全面解析 北京云巴巴信息技术有限公司 产品经理需求分析
    在当今快速发展的科技时代，项目研发管理软件已成为企业不可或缺的重要工具。面对市场上琳琅满目的产品，如何选择一款适合自己团队的项目研发管理软件呢？本文将围绕项目研发管理软件的选择标准，重点介绍TAPD卓越版的特点、优势以及使用体验，让你更好地理解和选择适合自己的项目研发管理软件。项目研发管理软件的选择标准在选择项目研发管理软件时，我们需要考虑以下几个方面的因素：功能全面性：软件是否覆盖了从需求管理、
  • 第二期心理咨询师培训 第1组分享第八天 张云511
    学会与问题共存—事情不会只有一个面读完本节，印象最深的点就是“扩大白色而非消灭黑色”。其实在班级管理中也是一样，我们暂时不要着急去消灭问题，而是注意学生哪些方面很不错，值得我们去扩大，我们要发现学生的资源与潜力，从正向的意义出发，发挥滴水穿石的力量，让一个个小改变汇集出巨大的改变！调整看事情的角度，不把生活问题扩大，是我们学习“与问题共存”的重要一步。换个角度看问题，会改变自己，也会感动别人！这样
  • 下一站深圳 默琊
    昨天已经买好3/15到深圳的机票了，原本上周还有点拖延症发作，不太积极，所以昨天就直接逼迫自己买机票，然后在订房，下周就是确认行业和把具体的面谈日程定下来。行业的选择上目前没有太大的偏好，上一份工作主要是风控和客服，客服部分也算是个小组长，有负责培训和一些案件SOP流程的制定等工作。总感觉客服这个职位的职涯发展只能是垂直的往更高的管理层走，对于横向发展似乎不容易，而鉴于做客服1年的感受，我不太喜欢
  • 一比一复刻手表哪里可以买到？推荐三个可靠渠道 腕表世界
    在我国，提及一比一复刻手表，人们总是充满好奇与争议。这种高度仿真的复刻手表，凭借其精湛的工艺、时尚的设计，以及与正品相差无几的质感，深受一部分消费者的喜爱。但与此同时，其背后的侵权争议也一直不断。那么，究竟哪里可以买到这些令人心动的一比一复刻手表呢？腕表咨询微信：10428850一、何为一比一复刻手表？一比一复刻手表，指的是严格按照正版手表的设计、尺寸和工艺制作的仿制品。这些手表在材质、外观、功能
  • 和自己结婚，是一种怎样的体验 只如初见_2020
    一个17岁谈恋爱，19岁结婚，然后离了三次婚的女人，站在台上说：“现在我结婚了，和那个一直以来，真正想在一起的人结婚了，那个人就是我自己。”她说，在我9岁前，我已经在二十几个寄养家庭中待过。我从童年到成年，就只有一个目标，不要被落下。而我实现这一目标的方式就是，我要结婚。我第一次的结婚对象，是我17岁时遇到的人。我们两年之后结了婚，当时我19岁。他是个非常好的人，来自于非常棒的家庭，他是工商管理硕
  • 【六】阿伟开始搭建Kafka学习环境 能源恒观 中间件学习kafkaspring
    阿伟开始搭建Kafka学习环境概述上一篇文章阿伟学习了Kafka的核心概念，并且把市面上流行的消息中间件特性进行了梳理和对比，方便大家在学习过程中进行对比学习，最后梳理了一些Kafka使用中经常遇到的Kafka难题以及解决思路，经过上一篇的学习我相信大家对Kafka有了初步的认识，本篇将继续学习Kafka。一、安装和配置学习一项技术首先要搭建一套服务，而Kafka的运行主要需要部署jdk、zook
  • 2022-08-28 蔚蓝一片晴
    初三暑假培训收获点滴从8月25至8月27日三天两晚的培训结束了，回到家中，该静下心来整理一下触动心灵的收获，成为成长的积淀。1.在优秀团队中快速成长与提升，做一名反思成长型教师一名专业型教师的教学指导包括了教学原理知识、案例知识、策略知识。面对教学中的遇到的有趣的情形、问题会去研究其理，寻找更好的教法学法对策。从新手到成熟型教师，再走向专业型教师，需要的是觉醒与反思，多进行案例研究，从案例中观察、
  • TDengine 签约前晨汽车，解锁智能出行的无限潜力 涛思数据（TDengine） tdengine汽车大数据
    在全球汽车产业转型升级的背景下，智能网联和新能源技术正迅速成为商用车行业的重要发展方向。随着市场对环保和智能化需求的日益增强，企业必须在技术创新和数据管理上不断突破，以满足客户对高效、安全和智能出行的期待。在这一背景下，前晨汽车凭借其在新能源智能商用车领域的前瞻性布局和技术实力，成为行业中的佼佼者。前晨汽车采用整车数据采集和全车数据打通策略，能够实时将数据推送至APP端客户。然而，这导致整体写入和
  • 11月，你好 自由自在的白云
    图片发自App今天是11月的第一天阳光明媚，秋日静好。给大家分享一个情绪管理的方法。也许你学习过，也许你还不曾了解，都没有关系，现在，我们一起来温习一下。就像孔老先生说的：学而时习之，温故而知新。种下对的种子，才会结出好的果实。种下情绪良好的种子，就可以收获良好的心态。“你瞧这些白云聚了又散，散了又聚，人生离合，亦复如斯。”世事如此，情绪的变化如山型曲线，一会来了，一会去了。还有那天课堂中老师讲，
  • CentOS的根目录下，/bin 和 /sbin 用途和权限 Energet!c Linux日常centoslinux运维
    CentOS的根目录下，/bin和/sbin用途和权限一、/bin(Binary)二、/sbin(SystemBinary)三、总结在CentOS的根目录下，/bin和/sbin目录有不同的用途和权限一、/bin(Binary)用途:存放系统的基本命令，这些命令对所有用户都是可用的。例如：ls、cp、mv、rm等。权限:普通用户和系统管理员都可以使用这些命令。二、/sbin(SystemBinar
  • 为什么你总是对下属不满意? ZhaoWu1050
    【ZhaoWu的听课笔记】大多数公司，都存在两种问题。我创业四年，更是体会深切。这两种问题就是：老板经常不满意下属的表现；下属总是不知道老板想要什么；虽然这两种问题普遍存在，其实解决方法并不复杂。这节课，我们再聊聊第一个问题：为什么老板经常不满意下属表现?其实，这背后也是一条管理常识。管理学家德鲁克先生早就说过：管理者的任务，不是去改变人。*来自《卓有成效的管理者》只是大多数老板和我一样，都是一边
  • 九月班级管理工作反思 追梦蜂
    这个月应该算是最难的一个月，我已N年没当班主任，然后我又开始当了。职称是一方面，想到我如果退休了，不能再接触学生了，那该是多么遗憾的事！我的学生梁*铭是我的榜样，她那么努力，那么拼，那么上进，为什么我不行？虽然我面临的工作很难，但是高考数学也不容易。她拿下来了！满分150分她考了146分！我目睹她的艰辛，她的拼搏！还有，我要为我的孩子做榜样，如何竭尽全力，实现梦想。还有，服务，为社会做事，也是会有
  • 但行好事，莫问前程 浅草拾光
    鸿星尔克被冲上了热搜，他可能做梦也没有想到自己的一个善举便迎来了他的春天。在这次河南救灾中很多明星企业都纷纷捐款，而一个快被人遗忘的品牌掏出了自己的家底。在自己年利润是亏损2.28亿的时候还大方的捐了五千万物资。热心的网友纷纷留言，大家都跑去直播间支持国货，去实体店买鞋子。以至于订单爆满，仓库清空。老板劝大家理性消费，大家反而更冲动。就是这样一种热情，这样一种情怀，感动了平凡的你我。大家都说华夏儿
  • 2021-01-24 9ce517ee104c
    【打卡素材】《香帅金融学讲义》【标题】公司治理：怎样同床异梦地过下去【日期】2021.1.24【字数】公司本质上是一连串的合约关系。降低合同执行中的各种摩擦是公司正常有效运行的基础。协同各方的利益、制衡各方的权力是关键。为解决利益冲突问题、协同各方利益，进行权力制衡的机制设计就是公司治理机制。001什么是公司治理治理是管理的基础，治理机制越好，权、责、利就越清晰，管理的目标也就会更容易实现。002
  • 大都会资本BMAN的2018年终总结 非线性思考
    1投资的本质是认知变现赚钱=足够的认知*高效的的变现。2投资的三大基石策略:提升认知高效变现知行合一3如果你亏钱了要么是认知的问题，要么是变现的问题，要么而是知行合一的问题。4投资需要知行合一，很简单的道理，却拦住了很多高手，是因为认知和行动中间还隔着人性。顶级的高手能把自己从贪嗔痴中抽离出来，顶级高手没有人性，只有原则。5如果你玩的是空气币，就不要幻想拿着它改变世界，那是你套出了幻觉，眼光放短一
  • windows下源码安装golang 616050468 golang安装golang环境windows
             系统： 64位win7， 开发环境：sublime text 2，  go版本： 1.4.1    1.  安装前准备(gcc, gdb, git)        golang在64位系
  • redis批量删除带空格的key bylijinnan redis
    redis批量删除的通常做法： redis-cli keys "blacklist*" | xargs redis-cli del 上面的命令在key的前后没有空格时是可以的，但有空格就不行了： $redis-cli keys "blacklist*" 1) "blacklist:12: [email protected]
  • oracle正则表达式的用法 0624chenhong oracle正则表达式
      方括号表达示 方括号表达式 描述 [[:alnum:]] 字母和数字混合的字符 [[:alpha:]] 字母字符 [[:cntrl:]] 控制字符 [[:digit:]] 数字字符 [[:graph:]] 图像字符 [[:lower:]] 小写字母字符 [[:print:]] 打印字符 [[:punct：]] 标点符号字符 [[:space:]]
  • 2048源码(核心算法有，缺少几个anctionbar，以后补上) 不懂事的小屁孩 2048
    2048游戏基本上有四部分组成， 1：主activity，包含游戏块的16个方格，上面统计分数的模块 2：底下的gridview，监听上下左右的滑动，进行事件处理， 3：每一个卡片，里面的内容很简单，只有一个text，记录显示的数字 4：Actionbar，是游戏用重新开始，设置等功能(这个在底下可以下载的代码里面还没有实现) 写代码的流程 1：设计游戏的布局，基本是两块，上面是分
  • jquery内部链式调用机理 换个号韩国红果果 JavaScriptjquery
    只需要在调用该对象合适(比如下列的setStyles)的方法后让该方法返回该对象（通过this  因为一旦一个函数称为一个对象方法的话那么在这个方法内部this（结合下面的setStyles）指向这个对象） function create(type){ var element=document.createElement(type); //this=element;
  • 你订酒店时的每一次点击 背后都是NoSQL和云计算 蓝儿唯美 NoSQL
    全球最大的在线旅游公司Expedia旗下的酒店预订公司，它运营着89个网站，跨越68个国家，三年前开始实验公有云，以求让客户在预订网站上查询假期酒店时得到更快的信息获取体验。 云端本身是用于驱动网站的部分小功能的，如搜索框的自动推荐功能，还能保证处理Hotels.com服务的季节性需求高峰整体储能。 Hotels.com的首席技术官Thierry Bedos上个月在伦敦参加“2015 Clou
  • java笔记1 a-john java
    1，面向对象程序设计（Object-oriented Propramming，OOP）：java就是一种面向对象程序设计。 2，对象：我们将问题空间中的元素及其在解空间中的表示称为“对象”。简单来说，对象是某个类型的实例。比如狗是一个类型，哈士奇可以是狗的一个实例，也就是对象。 3，面向对象程序设计方式的特性：     3.1 万物皆为对象。    
  • C语言 sizeof和strlen之间的那些事 C/C++软件开发求职面试题 必备考点（一） aijuans C/C++求职面试必备考点
            找工作在即，以后决定每天至少写一个知识点，主要是记录，逼迫自己动手、总结加深印象。当然如果能有一言半语让他人收益，后学幸运之至也。如有错误，还希望大家帮忙指出来。感激不尽。        后学保证每个写出来的结果都是自己在电脑上亲自跑过的，咱人笨，以前学的也半吊子。很多时候只能靠运行出来的结果再反过来
  • 程序员写代码时就不要管需求了吗？ asia007 程序员不能一味跟需求走
          编程也有2年了，刚开始不懂的什么都跟需求走，需求是怎样就用代码实现就行，也不管这个需求是否合理，是否为较好的用户体验。当然刚开始编程都会这样，但是如果有了2年以上的工作经验的程序员只知道一味写代码，而不在写的过程中思考一下这个需求是否合理，那么，我想这个程序员就只能一辈写敲敲代码了。       我的技术不是很好，但是就不代
  • Activity的四种启动模式 百合不是茶 android栈模式启动Activity的标准模式启动栈顶模式启动单例模式启动
    android界面的操作就是很多个activity之间的切换,启动模式决定启动的activity的生命周期 ;   启动模式xml中配置     <activity android:name=".MainActivity" android:launchMode="standard&quo
  • Spring中@Autowired标签与@Resource标签的区别 bijian1013 javaspring@Resource@Autowired@Qualifier
    Spring不但支持自己定义的@Autowired注解，还支持由JSR-250规范定义的几个注解，如：@Resource、 @PostConstruct及@PreDestroy。   1. @Autowired    @Autowired是Spring 提供的，需导入    Package:org.springframewo
  • Changes Between SOAP 1.1 and SOAP 1.2 sunjing ChangesEnableSOAP 1.1SOAP 1.2
    JAX-WS SOAP Version 1.2 Part 0: Primer (Second Edition) SOAP Version 1.2 Part 1: Messaging Framework (Second Edition) SOAP Version 1.2 Part 2: Adjuncts (Second Edition)   Which style of WSDL
  • 【Hadoop二】Hadoop常用命令 bit1129 hadoop
    以Hadoop运行Hadoop自带的wordcount为例，   hadoop脚本位于/home/hadoop/hadoop-2.5.2/bin/hadoop，需要说明的是，这些命令的使用必须在Hadoop已经运行的情况下才能执行   Hadoop HDFS相关命令  hadoop fs -ls  列出HDFS文件系统的第一级文件和第一级
  • java异常处理（初级） 白糖_ javaDAOspring虚拟机Ajax
    从学习到现在从事java开发一年多了，个人觉得对java只了解皮毛，很多东西都是用到再去慢慢学习，编程真的是一项艺术，要完成一段好的代码，需要懂得很多。 最近项目经理让我负责一个组件开发，框架都由自己搭建，最让我头疼的是异常处理，我看了一些网上的源码，发现他们对异常的处理不是很重视，研究了很久都没有找到很好的解决方案。后来有幸看到一个200W美元的项目部分源码，通过他们对异常处理的解决方案，我终
  • 记录整理-工作问题 braveCS 工作
    1）那位同学还是CSV文件默认Excel打开看不到全部结果。以为是没写进去。同学甲说文件应该不分大小。后来log一下原来是有写进去。只是Excel有行数限制。那位同学进步好快啊。 2）今天同学说写文件的时候提示jvm的内存溢出。我马上反应说那就改一下jvm的内存大小。同学说改用分批处理了。果然想问题还是有局限性。改jvm内存大小只能暂时地解决问题，以后要是写更大的文件还是得改内存。想问题要长远啊
  • org.apache.tools.zip实现文件的压缩和解压，支持中文 bylijinnan apache
    刚开始用java.util.Zip，发现不支持中文（网上有修改的方法，但比较麻烦） 后改用org.apache.tools.zip org.apache.tools.zip的使用网上有更简单的例子 下面的程序根据实际需求，实现了压缩指定目录下指定文件的方法 import java.io.BufferedReader; import java.io.BufferedWrit
  • 读书笔记-4 chengxuyuancsdn 读书笔记
    1、JSTL 核心标签库标签 2、避免SQL注入 3、字符串逆转方法 4、字符串比较compareTo 5、字符串替换replace 6、分拆字符串 1、JSTL 核心标签库标签共有13个， 学习资料：http://www.cnblogs.com/lihuiyy/archive/2012/02/24/2366806.html 功能上分为4类： (1)表达式控制标签：out
  • [物理与电子]半导体教材的一个小问题 comsci 问题
          各种模拟电子和数字电子教材中都有这个词汇-空穴       书中对这个词汇的解释是; 当电子脱离共价键的束缚成为自由电子之后,共价键中就留下一个空位,这个空位叫做空穴       我现在回过头翻大学时候的教材,觉得这个
  • Flashback Database --闪回数据库 daizj oracle闪回数据库
    Flashback 技术是以Undo segment中的内容为基础的， 因此受限于UNDO_RETENTON参数。要使用flashback 的特性，必须启用自动撤销管理表空间。 在Oracle 10g中， Flash back家族分为以下成员： Flashback Database， Flashback Drop，Flashback Query(分Flashback Query,Flashbac
  • 简单排序:插入排序 dieslrae 插入排序
    public void insertSort(int[] array){ int temp; for(int i=1;i<array.length;i++){ temp = array[i]; for(int k=i-1;k>=0;k--)
  • C语言学习六指针小示例、一维数组名含义，定义一个函数输出数组的内容 dcj3sjt126com c
    # include <stdio.h> int main(void) { int * p; //等价于 int *p 也等价于 int* p; int i = 5; char ch = 'A'; //p = 5; //error //p = &ch; //error //p = ch; //error p = &i; //
  • centos下php redis扩展的安装配置3种方法 dcj3sjt126com redis
    方法一 1.下载php redis扩展包  代码如下 复制代码 #wget http://redis.googlecode.com/files/redis-2.4.4.tar.gz 2 tar -zxvf 解压压缩包，cd /扩展包 （进入扩展包然后 运行phpize 一下是我环境中phpize的目录，/usr/local/php/bin/phpize (一定要
  • 线程池(Executors) shuizhaosi888 线程池
    在java类库中，任务执行的主要抽象不是Thread，而是Executor，将任务的提交过程和执行过程解耦 public interface Executor { void execute(Runnable command); }   public class RunMain implements Executor{ @Override pub
  • openstack 快速安装笔记 haoningabc openstack
    前提是要配置好yum源 版本icehouse，操作系统redhat6.5 最简化安装，不要cinder和swift 三个节点 172 control节点keystone glance horizon 173 compute节点nova 173 network节点neutron control /etc/sysctl.conf net.ipv4.ip_forward =
  • 从c面向对象的实现理解c++的对象（二） jimmee C++面向对象虚函数
    1. 类就可以看作一个struct，类的方法，可以理解为通过函数指针的方式实现的，类对象分配内存时，只分配成员变量的，函数指针并不需要分配额外的内存保存地址。 2. c++中类的构造函数，就是进行内存分配(malloc)，调用构造函数 3. c++中类的析构函数，就时回收内存(free) 4. c++是基于栈和全局数据分配内存的，如果是一个方法内创建的对象，就直接在栈上分配内存了。 专门在
  • 如何让那个一个div可以拖动 lingfeng520240 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/1999/xhtml
  • 第10章 高级事件（中） onestopweb 事件
    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/
  • 计算两个经纬度之间的距离 roadrunners 计算纬度LBS经度距离
    要解决这个问题的时候，到网上查了很多方案，最后计算出来的都与百度计算出来的有出入。下面这个公式计算出来的距离和百度计算出来的距离是一致的。 /** * * @param longitudeA * 经度A点 * @param latitudeA * 纬度A点 * @param longitudeB *
  • 最具争议的10个Java话题 tomcat_oracle java
    1、Java8已经到来。什么！？ Java8 支持lambda。哇哦，RIP Scala！ 　　随着Java8 的发布，出现很多关于新发布的Java8是否有潜力干掉Scala的争论，最终的结论是远远没有那么简单。Java8可能已经在Scala的lambda的包围中突围，但Java并非是函数式编程王位的真正觊觎者。 　 　2、Java 9 即将到来 　　 Oracle早在8月份就发布
  • zoj 3826 Hierarchical Notation(模拟) 阿尔萨斯 rar
    题目链接：zoj 3826 Hierarchical Notation 题目大意：给定一些结构体，结构体有value值和key值，Q次询问，输出每个key值对应的value值。 解题思路：思路很简单，写个类词法的递归函数，每次将key值映射成一个hash值，用map映射每个key的value起始终止位置，预处理完了查询就很简单了。 这题是最后10分钟出的，因为没有考虑value为{}的情
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他