kafka + sparkStreaming 学习笔记

最新推荐文章于 2024-07-01 14:48:29 发布
最新推荐文章于 2024-07-01 14:48:29 发布
阅读量1.2w 收藏 46
点赞数 4
分类专栏： 大数据 文章标签： kafka 消息队列 流式计算
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/panleiaiying/article/details/85229346
版权

Kafka

kafka是一个高吞吐的分布式消息队列系统。特点是生产者消费者模式，先进先出（FIFO）保证顺序，自己不丢数据，默认每隔7天清理数据。消息列队常见场景：系统之间解耦合、峰值压力缓冲、异步通信。
在这里插入图片描述

  • producer : 消息生产者

  • consumer : 消息消费之

  • broker : kafka集群的server，负责处理消息读、写请求，存储消息，在kafka cluster这一层这里，其实里面是有很多个broker

  • topic : 消息队列/分类相当于队列，里面有生产者和消费者模型

  • zookeeper : 元数据信息存在zookeeper中，包括：存储消费偏移量，topic话题信息，partition信息

  • 1、一个topic分成多个partition

  • 2、每个partition内部消息强有序， 其中的每个消息都有一个序号交offset

  • 3、一个partition 只对应一个broker, 一个broker 可以管理多个partition

  • 4、 消息直接写入文件，并不保存在内存中

  • 5、按照时间策略， 默认一周删除， 而不是消息消费完就删除

  • 6、producer自己决定网那个partition写消息，可以是轮询的负载均衡，或者是基于hash的partition策略

在这里插入图片描述

kafka 的消息消费模型

  • consumer 自己维护消费到哪个offset
  • 每个consumer都有对应的group
  • group 内是queue消费模型
    – 各个consumer消费不同的partition
    – 一个消息在group内只消费一次
  • 各个group各自独立消费，互不影响
    在这里插入图片描述

kafka 特点

  • 生存者消费模型：FIFO； partition内部是FIFO的， partition之间不是FIFO
  • 高性能：单节点支持上千个客户端，百MB/s 吞吐
  • 持久性：直接持久在普通的磁盘上，性能比较好； 直接append 方式追加到磁盘，数据不会丢
  • 分布式：数据副本冗余，流量负载均衡、可扩展； 数据副本，也就是同一份数据可以到不同的broker上面去，也就是当一份数据， 磁盘坏掉，数据不亏丢失
  • 很灵活： 消息长时间持久化+Cilent维护消费状态； 1、持久花时间长，可以是一周、一天，2、可以自定义消息偏移量

kafka 安装

  1. https://www.apache.org/dyn/closer.cgi?path=/kafka/2.0.1/kafka_2.11-2.0.1.tgz
    下载
  2. 解压压缩包，修改config 文件夹下 server.properties
   	 // 节点编号：（不同节点按0,1,2,3整数来配置）
    	broker.id = 0
    	// 数据存放目录
    	log.dirs = /log
    	// zookeeper 集群配置
    	zookeeper.connect=node1:2181,node2:2181,node3:2181

  1. 启动 bin/kafka-server-start.sh config/server.properties

    可以单独配置一个启动文件
    vim start-kafka.sh

    nohup bin/kafka-server-start.sh   config/server.properties > kafka.log 2>&1 &

授权 chmod 755 start-kafka.sh

kafka基础命令
创建topic./kafka-topics.sh --zookeeper node1:2181,node2:2181,node3:2181 --create --topic t0315 --partitions 3 --replication-factor 3

查看topic： ./kafka-topics.sh --zookeeper node1:2181,node2:2181,node3:2181 --list

生产者：./kafka-console-producer.sh --topic t0315 --broker-list node1:9092,node2:9092,node3:9092

消费者：./kafka-console-consumer.sh --bootstrap-server node1:9092,node2:9092,node3:9092 --topic t0315

获取描述： ./kafka-topics.sh --describe --zookeeper node1:2181,node2:2181,node3:2181 --topic t0315

kafka中有一个被称为优先副本（preferred replicas）的概念。如果一个分区有3个副本，且这3个副本的优先级别分别为0,1,2，根据优先副本的概念，0会作为leader 。当0节点的broker挂掉时，会启动1这个节点broker当做leader。当0节点的broker再次启动后，会自动恢复为此partition的leader。不会导致负载不均衡和资源浪费，这就是leader的均衡机制。
在配置文件conf/ server.properties中配置开启（默认就是开启）：auto.leader.rebalance.enable true

Code 部分

sparkStreaming 的direact 方式

<properties>
   <spark.version>2.2.0</spark.version>
 </properties>
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.11</version>
    <scope>test</scope>
  </dependency>
  <dependency>
    <groupId>org.apache.spark</groupId>
    <artifactId>spark-streaming-kafka-0-8_2.11</artifactId>
    <version>${spark.version}</version>
   <!-- <exclusions>
      <exclusion>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-log4j12</artifactId>
      </exclusion>
      <exclusion>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
      </exclusion>
    </exclusions>-->
  </dependency>

  <dependency>
    <groupId>org.apache.spark</groupId>
    <artifactId>spark-streaming_2.11</artifactId>
    <version>${spark.version}</version>
  </dependency>
  <!-- https://mvnrepository.com/artifact/org.apache.spark/spark-core -->
  <dependency>
    <groupId>org.apache.spark</groupId>
    <artifactId>spark-core_2.11</artifactId>
    <version>${spark.version}</version>
  </dependency>
  <!-- https://mvnrepository.com/artifact/org.apache.spark/spark-hive -->
  <dependency>
    <groupId>org.apache.spark</groupId>
    <artifactId>spark-hive_2.11</artifactId>
    <version>${spark.version}</version>
  </dependency>
  <!-- https://mvnrepository.com/artifact/org.apache.spark/spark-sql -->
  <dependency>
    <groupId>org.apache.spark</groupId>
    <artifactId>spark-sql_2.11</artifactId>
    <version>${spark.version}</version>
  </dependency>

producer 部分：

import kafka.serializer.StringEncoder;
import org.apache.kafka.clients.producer.ProducerRecord;
import java.util.Properties;

/**
 *@Author PL
 *@Date 2018/12/27 10:59
 *@Description TODO
 **/
public class KafkaProducer {
    public static void main(String[] args) throws InterruptedException {

        Properties pro = new Properties();
        pro.put("bootstrap.servers","node1:9092,node2:9092,node3:9092");
        pro.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        pro.put("value.serializer","org.apache.kafka.common.serialization.StringSerializer");
        //Producer<String,String> producer = new Producer<String, String>(new ProducerConfig(pro));
        //org.apache.kafka.clients.producer.KafkaProducer producer1 = new Kafka
        org.apache.kafka.clients.producer.KafkaProducer<String,String> producer = new org.apache.kafka.clients.producer.KafkaProducer<String, String>(pro);
        System.out.println("11");
        String topic = "t0315";
        String msg = "hello word";
        for (int i =0 ;i <100;i++) {
            producer.send(new ProducerRecord<String, String>(topic, "hello", msg));
            System.out.println(msg);
        }
        producer.close();
    }
}

customer

import kafka.serializer.StringDecoder;
import org.apache.spark.SparkConf;
import org.apache.spark.api.java.function.FlatMapFunction;
import org.apache.spark.api.java.function.Function2;
import org.apache.spark.api.java.function.PairFunction;
import org.apache.spark.streaming.Durations;
import org.apache.spark.streaming.api.java.JavaDStream;
import org.apache.spark.streaming.api.java.JavaPairDStream;
import org.apache.spark.streaming.api.java.JavaPairInputDStream;
import org.apache.spark.streaming.api.java.JavaStreamingContext;
import org.apache.spark.streaming.kafka.KafkaUtils;
import scala.Tuple2;

import java.util.*;

/**
 *@Author PL
 *@Date 2018/12/26 13:28
 *@Description TODO
 **/
public class SparkStreamingForkafka {
    public static void main(String[] args) throws InterruptedException {
        SparkConf sc = new SparkConf().setMaster("local[2]").setAppName("test");
        JavaStreamingContext jsc = new JavaStreamingContext(sc, Durations.seconds(5));
        Map<String,String> kafkaParam = new HashMap<>();
        kafkaParam.put("metadata.broker.list","node1:9092,node2:9092,node3:9092");
        //kafkaParam.put("t0315",1);
        HashSet<String> topic = new HashSet<>();
        topic.add("t0315");

        //JavaPairInputDStream<String, String> line = KafkaUtils.createStream(jsc,"node1:9092,node2:9092,node3:9092","wordcountGrop",kafkaParam);
        JavaPairInputDStream<String, String> line = KafkaUtils.createDirectStream(jsc, String.class, String.class, StringDecoder.class, StringDecoder.class, kafkaParam, topic);
        JavaDStream<String> flatLine = line.flatMap(new FlatMapFunction<Tuple2<String, String>, String>() {
            @Override
            public Iterator<String> call(Tuple2<String, String> tuple2) throws Exception {
                return Arrays.asList(tuple2._2.split(" ")).iterator();
            }
        });

        JavaPairDStream<String, Integer> pair = flatLine.mapToPair(new PairFunction<String, String, Integer>() {
            @Override
            public Tuple2<String, Integer> call(String s) throws Exception {
                return new Tuple2<String, Integer>(s, 1);
            }
        });

        JavaPairDStream<String, Integer> count = pair.reduceByKey(new Function2<Integer, Integer, Integer>() {
            @Override
            public Integer call(Integer integer, Integer integer2) throws Exception {
                return integer + integer2;
            }
        });

        count.print();

        jsc.start();
        jsc.awaitTermination();
        jsc.close();;
    }
}

上述方式为一个SparkStreaming 的消费者， direct方式就是把kafka当成一个存储数据的库，spark 自己维护offset。假设，driver 端宕机了， 之后再重启，会从offset 那一部分开始取?
所以我们需要将kafka 的offset 保存在文件中， 宕机之后在启动时去恢复文件中的offset 读取数据。

import kafka.serializer.StringDecoder;
import org.apache.spark.SparkConf;
import org.apache.spark.api.java.function.FlatMapFunction;
import org.apache.spark.api.java.function.Function0;
import org.apache.spark.api.java.function.Function2;
import org.apache.spark.api.java.function.PairFunction;
import org.apache.spark.streaming.Durations;
import org.apache.spark.streaming.api.java.JavaDStream;
import org.apache.spark.streaming.api.java.JavaPairDStream;
import org.apache.spark.streaming.api.java.JavaPairInputDStream;
import org.apache.spark.streaming.api.java.JavaStreamingContext;
import org.apache.spark.streaming.kafka.KafkaUtils;
import scala.Tuple2;

import java.util.*;

/**
 *@Author PL
 *@Date 2018/12/26 13:28
 *@Description TODO
 **/
public class KafkaCheckPoint {
    public static void main(String[] args) throws InterruptedException {
        final String checkPoint = "./checkPoint";

        Function0<JavaStreamingContext> scFunction = new Function0<JavaStreamingContext>() {
            @Override
            public JavaStreamingContext call() throws Exception {
                return createJavaStreamingContext();
            }
        };
        // 如果存在checkport 就恢复数据，不存在就直接运行
        JavaStreamingContext jsc = JavaStreamingContext.getOrCreate(checkPoint, scFunction);
        jsc.start();
        jsc.awaitTermination();
        jsc.close();;
    }


    public static  JavaStreamingContext createJavaStreamingContext(){
        System.out.println("初始化");  // 第一次会执行，宕机之后重启执行数据恢复时不执行
        final SparkConf sc = new SparkConf().setMaster("local").setAppName("test");
        JavaStreamingContext jsc = new JavaStreamingContext(sc, Durations.seconds(5));
        /**
        * checkpoint 保存
        * 	1、 配置信息
        *	2、Dstream 执行逻辑
        *	3、Job 的执行进度
        *	4、offset
        */
        jsc.checkpoint("./checkPoint");

        Map<String,String> kafkaParam = new HashMap<>();
        kafkaParam.put("metadata.broker.list","node1:9092,node2:9092,node3:9092");
        HashSet<String> topic = new HashSet<>();
        topic.add("t0315");

        JavaPairInputDStream<String, String> line = KafkaUtils.createDirectStream(jsc, String.class, String.class, StringDecoder.class, StringDecoder.class, kafkaParam, topic);
        JavaDStream<String> flatLine = line.flatMap(new FlatMapFunction<Tuple2<String, String>, String>() {
            @Override
            public Iterator<String> call(Tuple2<String, String> tuple2) throws Exception {
                return Arrays.asList(tuple2._2.split(" ")).iterator();
            }
        });

        JavaPairDStream<String, Integer> pair = flatLine.mapToPair(new PairFunction<String, String, Integer>() {
            @Override
            public Tuple2<String, Integer> call(String s) throws Exception {
                return new Tuple2<String, Integer>(s, 1);
            }
        });

        JavaPairDStream<String, Integer> count = pair.reduceByKey(new Function2<Integer, Integer, Integer>() {
            @Override
            public Integer call(Integer integer, Integer integer2) throws Exception {
                return integer + integer2;
            }
        });
        count.print();
        return jsc;
    }

}

这次我们启动的时候会发现先从checkpoint中恢复数据， 从上次宕机的数据开始读取并执行。但是，当我们更改功能时，发现新修改的部分没有执行， 还是执行的上次保存的代码。。。。。。。

这时候可以把offset 保存至zookeeper中

主方法

import com.pl.data.offset.getoffset.GetTopicOffsetFromKafkaBroker;
import com.pl.data.offset.getoffset.GetTopicOffsetFromZookeeper;
import kafka.common.TopicAndPartition;
import org.apache.log4j.Logger;
import org.apache.spark.streaming.api.java.JavaStreamingContext;

import java.util.Map;

public class UseZookeeperManageOffset {
	/**
	 * 使用log4j打印日志，“UseZookeeper.class” 设置日志的产生类
	 */
	static final Logger logger = Logger.getLogger(UseZookeeperManageOffset.class);
	
	
	public static void main(String[] args) throws InterruptedException {
		
		/**
		 * 从kafka集群中得到topic每个分区中生产消息的最大偏移量位置
		 */
		Map<TopicAndPartition, Long> topicOffsets = GetTopicOffsetFromKafkaBroker.getTopicOffsets("node1:9092,node2:9092,node3:9092", "t0315");
		
		/**
		 * 从zookeeper中获取当前topic每个分区 consumer 消费的offset位置
		 */
		Map<TopicAndPartition, Long> consumerOffsets = 
				GetTopicOffsetFromZookeeper.getConsumerOffsets("node1:2181,node2:2181,node3:2181","pl","t0315");
		
		/**
		 * 合并以上得到的两个offset ，
		 * 	思路是：
		 * 		如果zookeeper中读取到consumer的消费者偏移量，那么就zookeeper中当前的offset为准。
		 * 		否则，如果在zookeeper中读取不到当前消费者组消费当前topic的offset，就是当前消费者组第一次消费当前的topic，
		 * 			offset设置为topic中消息的最大位置。
		 */

		if(null!=consumerOffsets && consumerOffsets.size()>0){
            topicOffsets.putAll(consumerOffsets);
        }
		/**
		 * 如果将下面的代码解开，是将topicOffset 中当前topic对应的每个partition中消费的消息设置为0，就是从头开始。
		 */
		/*for(Map.Entry<TopicAndPartition, Long> item:topicOffsets.entrySet()){
          item.setValue(0l);
		}*/
		
		/**
		 * 构建SparkStreaming程序，从当前的offset消费消息
		 */
		JavaStreamingContext jsc = SparkStreamingDirect.getStreamingContext(topicOffsets,"pl");
		jsc.start();
		jsc.awaitTermination();
		jsc.close();
		
	}
}

获取kafka中当前的offset 偏移量(kafka API)

import kafka.api.PartitionOffsetRequestInfo;
import kafka.cluster.Broker;
import kafka.common.TopicAndPartition;
import kafka.javaapi.OffsetRequest;
import kafka.javaapi.OffsetResponse;
import kafka.javaapi.PartitionMetadata;
import kafka.javaapi.TopicMetadata;
import kafka.javaapi.TopicMetadataRequest;
import kafka.javaapi.TopicMetadataResponse;
import kafka.javaapi.consumer.SimpleConsumer;

/**
 * 测试之前需要启动kafka
 * @author root
 *
 */
public class GetTopicOffsetFromKafkaBroker {
	public static void main(String[] args) {
		
		Map<TopicAndPartition, Long> topicOffsets = getTopicOffsets("node1:9092,node2:9092,node3:9092", "t0315");
		Set<Entry<TopicAndPartition, Long>> entrySet = topicOffsets.entrySet();
		for(Entry<TopicAndPartition, Long> entry : entrySet) {
			TopicAndPartition topicAndPartition = entry.getKey();
			Long offset = entry.getValue();
			String topic = topicAndPartition.topic();
			int partition = topicAndPartition.partition();
			System.out.println("topic = "+topic+",partition = "+partition+",offset = "+offset);
		}
	
	}
	
	/**
	 * 从kafka集群中得到当前topic，生产者在每个分区中生产消息的偏移量位置
	 * @param KafkaBrokerServer
	 * @param topic
	 * @return
	 */
	public static Map<TopicAndPartition,Long> getTopicOffsets(String KafkaBrokerServer, String topic){
		Map<TopicAndPartition,Long> retVals = new HashMap<TopicAndPartition,Long>();
		// 遍历kafka集群，并拆分
		for(String broker:KafkaBrokerServer.split(",")){
			SimpleConsumer simpleConsumer = new SimpleConsumer(broker.split(":")[0],Integer.valueOf(broker.split(":")[1]), 64*10000,1024,"consumer"); 
			TopicMetadataRequest topicMetadataRequest = new TopicMetadataRequest(Arrays.asList(topic));
			TopicMetadataResponse topicMetadataResponse = simpleConsumer.send(topicMetadataRequest);
			List<TopicMetadata> topicMetadataList = topicMetadataResponse.topicsMetadata();
			// 遍历每个topic下的元数据
			for (TopicMetadata metadata : topicMetadataList) {
				// 遍历元数据下的分区
				for (PartitionMetadata part : metadata.partitionsMetadata()) {
					Broker leader = part.leader();
					if (leader != null) { 
						TopicAndPartition topicAndPartition = new TopicAndPartition(topic, part.partitionId()); 
						
						PartitionOffsetRequestInfo partitionOffsetRequestInfo = new PartitionOffsetRequestInfo(kafka.api.OffsetRequest.LatestTime(), 10000); 
						OffsetRequest offsetRequest = new OffsetRequest(ImmutableMap.of(topicAndPartition, partitionOffsetRequestInfo), kafka.api.OffsetRequest.CurrentVersion(), simpleConsumer.clientId()); 
						OffsetResponse offsetResponse = simpleConsumer.getOffsetsBefore(offsetRequest); 
						
						if (!offsetResponse.hasError()) { 
							long[] offsets = offsetResponse.offsets(topic, part.partitionId()); 
							retVals.put(topicAndPartition, offsets[0]);
						}
					}
				}
			}
			simpleConsumer.close();
		}
		return retVals;
	}
}

获取zookeeper中上次的消费的offset

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.retry.RetryUntilElapsed;

import com.fasterxml.jackson.databind.ObjectMapper;

import kafka.common.TopicAndPartition;

public class GetTopicOffsetFromZookeeper {
   
   public static Map<TopicAndPartition,Long> getConsumerOffsets(String zkServers,String groupID, String topic) { 
   	Map<TopicAndPartition,Long> retVals = new HashMap<TopicAndPartition,Long>();
   	// 连接 zookeeper
   	ObjectMapper objectMapper = new ObjectMapper();
   	CuratorFramework  curatorFramework = CuratorFrameworkFactory.builder()
   			.connectString(zkServers).connectionTimeoutMs(1000)
   			.sessionTimeoutMs(10000).retryPolicy(new RetryUntilElapsed(1000, 1000)).build();
   	curatorFramework.start();
   	
   	try{
   		String nodePath = "/consumers/"+groupID+"/offsets/" + topic;
   		if(curatorFramework.checkExists().forPath(nodePath)!=null){
   			List<String> partitions=curatorFramework.getChildren().forPath(nodePath);
   			for(String partiton:partitions){
   				int partitionL=Integer.valueOf(partiton);
   				Long offset=objectMapper.readValue(curatorFramework.getData().forPath(nodePath+"/"+partiton),Long.class);
   				TopicAndPartition topicAndPartition=new TopicAndPartition(topic,partitionL);
   				retVals.put(topicAndPartition, offset);
   			}
   		}
   	}catch(Exception e){
   		e.printStackTrace();
   	}
   	curatorFramework.close();
   	
   	return retVals;
   } 
   
   
   public static void main(String[] args) {
   	Map<TopicAndPartition, Long> consumerOffsets = getConsumerOffsets("node1:2181,node2:2181,node3:2181","pl","t0315");
   	Set<Entry<TopicAndPartition, Long>> entrySet = consumerOffsets.entrySet();
   	for(Entry<TopicAndPartition, Long> entry : entrySet) {
   		TopicAndPartition topicAndPartition = entry.getKey();
   		String topic = topicAndPartition.topic();
   		int partition = topicAndPartition.partition();
   		Long offset = entry.getValue();
   		System.out.println("topic = "+topic+",partition = "+partition+",offset = "+offset);
   	}
   }
}

读取kafka中指定offset开始的消息

import com.fasterxml.jackson.databind.ObjectMapper;
import kafka.common.TopicAndPartition;
import kafka.message.MessageAndMetadata;
import kafka.serializer.StringDecoder;
import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.retry.RetryUntilElapsed;
import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.function.Function;
import org.apache.spark.api.java.function.VoidFunction;
import org.apache.spark.streaming.Durations;
import org.apache.spark.streaming.api.java.JavaDStream;
import org.apache.spark.streaming.api.java.JavaInputDStream;
import org.apache.spark.streaming.api.java.JavaStreamingContext;
import org.apache.spark.streaming.kafka.HasOffsetRanges;
import org.apache.spark.streaming.kafka.KafkaUtils;
import org.apache.spark.streaming.kafka.OffsetRange;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.atomic.AtomicReference;

public class SparkStreamingDirect {
	public static JavaStreamingContext getStreamingContext(Map<TopicAndPartition, Long> topicOffsets,final String groupID){
		SparkConf conf = new SparkConf().setMaster("local[*]").setAppName("SparkStreamingOnKafkaDirect");
		conf.set("spark.streaming.kafka.maxRatePerPartition", "10");
        JavaStreamingContext jsc = new JavaStreamingContext(conf, Durations.seconds(5));
//        jsc.checkpoint("/checkpoint");
        Map<String, String> kafkaParams = new HashMap<String, String>();
        kafkaParams.put("metadata.broker.list","node1:9092,node2:9092,node3:9092");
//        kafkaParams.put("group.id","MyFirstConsumerGroup");
        for(Map.Entry<TopicAndPartition,Long> entry:topicOffsets.entrySet()){
    		System.out.println(entry.getKey().topic()+"\t"+entry.getKey().partition()+"\t"+entry.getValue());
        }

        JavaInputDStream<String> message = KafkaUtils.createDirectStream(
			jsc,
	        String.class,
	        String.class, 
	        StringDecoder.class,
	        StringDecoder.class, 
	        String.class,
	        kafkaParams,
	        topicOffsets, 
	        new Function<MessageAndMetadata<String,String>,String>() {
				private static final long serialVersionUID = 1L;
				public String call(MessageAndMetadata<String, String> v1)throws Exception {
	                return v1.message();
	            }
	        }
		);
        final AtomicReference<OffsetRange[]> offsetRanges = new AtomicReference<>();
        JavaDStream<String> lines = message.transform(new Function<JavaRDD<String>, JavaRDD<String>>() {
			private static final long serialVersionUID = 1L;
			@Override
            public JavaRDD<String> call(JavaRDD<String> rdd) throws Exception {
              OffsetRange[] offsets = ((HasOffsetRanges) rdd.rdd()).offsetRanges();
              offsetRanges.set(offsets);
              return rdd;
            }
          }
        );
        message.foreachRDD(new VoidFunction<JavaRDD<String>>(){
            /**
			 * 
			 */
			private static final long serialVersionUID = 1L;

			@Override
            public void call(JavaRDD<String> t) throws Exception {
                ObjectMapper objectMapper = new ObjectMapper();
                CuratorFramework  curatorFramework = CuratorFrameworkFactory.builder()
                        .connectString("node1:2181,node2:2181,node3:2181").connectionTimeoutMs(1000)
                        .sessionTimeoutMs(10000).retryPolicy(new RetryUntilElapsed(1000, 1000)).build();
                curatorFramework.start();
                for (OffsetRange offsetRange : offsetRanges.get()) {
                	long fromOffset = offsetRange.fromOffset();
                	long untilOffset = offsetRange.untilOffset();
                	final byte[] offsetBytes = objectMapper.writeValueAsBytes(offsetRange.untilOffset());
                    String nodePath = "/consumers/"+groupID+"/offsets/" + offsetRange.topic()+ "/" + offsetRange.partition();
                    System.out.println("nodePath = "+nodePath);
                    System.out.println("fromOffset = "+fromOffset+",untilOffset="+untilOffset);
                    if(curatorFramework.checkExists().forPath(nodePath)!=null){
                        curatorFramework.setData().forPath(nodePath,offsetBytes);
                    }else{
                        curatorFramework.create().creatingParentsIfNeeded().forPath(nodePath, offsetBytes);
                    }
                }
                curatorFramework.close();
            }

        });
        lines.print();
        return jsc;
    }
}
今夕何年-
关注
  • 4
    点赞
  • 踩
  • 46
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spark学习笔记Spark Streaming的使用
08-25
5. Spark Streaming 整合 Kafka * 基于 Receiver 的方式：使用 Receiver 来接收数据，偏移量是由 ZooKeeper 来维护的，编程简单但是效率低。 * 基于 Direct 的方式：使用 Direct 来接收数据，偏移量是由我们来手动...
spark:spark学习笔记
05-26
【Spark：Spark学习笔记】 Spark，作为大数据处理领域的重要框架，以其高效、易用和弹性伸缩性赢得了广泛赞誉。本笔记将从基础概念出发，深入探讨Spark的核心特性，包括RDD（Resilient Distributed Datasets）、...
搭建基于新闻api+kafka+sparkstreaming+fine-tuning模型+clickhouse的微批次新闻文本情感分析平台
michel_的博客
04-23 710
在当前金融变换莫测的时代，如何从金融新闻标题获取民生对股市，经济，企业的看法态度尤为重要。本项目为了应对当前互联网**人工智能**发展趋势以及**大数据**发展潮流，搭建了一个从0到1的基于***kakfa+sparkstreaming+NLP深度学习模型+clickhouse数据库***的***全自动微批式金融文本分析***的项目。最终实现**数秒**内可分析**千条**新闻头条情感信息
Spark基础：Kafka分布式消息系统
IT深耕十余载，大道之简
05-29 324
Kafka是一个由Apache软件基金会开发的开源分布式消息系统，它最初由LinkedIn公司开发和维护，后于2011年初开源。Kafka被设计为一个高吞吐量、低延迟的平台，用于处理实时数据流。下面将详细介绍Kafka分布式消息系统的几个关键方面。总结来说，Kafka是一个高性能、分布式、可靠的消息系统，被广泛应用于实时数据处理和流处理场景。与Spark的集成使得Kafka能够更好地发挥其在大数据处理和分析方面的优势。
20200621sparkstreaming学习笔记flume+zookeerpeer+kafka
weixin_44611305的博客
06-22 107
弱弱的吐槽一句mac系统的catalina，太容易发烫了，我实在受不了了，然后昨天刷回Mojave了，不仅遇到很多坑，打电话给客服感觉问他们不如自己看文档== 最后搞了一天终于刷回Mojava 10.14.6了，我再也不升级了，电脑资料全没了== SparkStreaming 安装Flume export FLUME_HOME=/home/hadoop/app/apache-flume-1.6.0-cdh5.16.2-bin export PATH=$FLUME_HOME/bin:$PATH 从官网
Kafka学习笔记-Flume整合Kafka整合SparkStreaming
PURSUE ONE PIECE
06-22 1103
Flume Kafka 环境信息： apache-flume-1.6.0-bin.tar.gz kafka_2.11-0.10.0.0.tgz scala 2.11 1、启动Zookeeper（这里用的是Kafka自带的Zookeeper） $bin/zookeeper-server-start.sh -daemon config/zookeeper.properties
Kafka和Spark Streaming的组合使用学习笔记（Spark 3.5.1）
m0_74972727的博客
05-08 862
二、启动Kafaka 1.首先需要启动Kafka，打开一个终端，输入下面命令启动Zookeeper服务： 注意：以上现象是Zookeeper服务器已经启动，正在处于服务状态。不要关闭！ 注意：同样不要误以为死机了，而是Kafka服务器已经启动，正在处于服务状态。 2.然后，可以执行如下命令，查看名称为“wordsender”的Topic是否已经成功创建： 注意，所有这些终端窗口都不要关闭，要继续留着后面使用。Kafka和Flume等高级输入源，需要依赖独立的库（jar文件），
大数据——SparkStreaming学习笔记
koooooooo5的博客
05-07 322
Spark 一、SparkStreaming ​ Spark Streaming 用于流式数据的处理（准实时，微序列）。Spark Streaming 支持的数据输入源很多，例如：Kafka、 Flume、Twitter、ZeroMQ 和简单的 TCP 套接字等等。数据输入后可以用 Spark 的高度抽象原语，如：map、reduce、join、window 等进行运算。而结果也能保存在很多地方，如 HDFS，数据库等。 **DStream（离散化流，discretized stream）**是随时间
SparkStreaming 学习笔记
十二的博客
07-28 257
SparkStreaming概述 1.1 Spark Streaming是什么 Spark Streaming用于流式数据的处理 1.Spark Streaming支持的数据输入源头很多，例如：Kafka，Flume，HDFS等 2.数据输入后可以用Spark的高度抽象原语如：map，reduce，join，window等 3.而结果也能保存在很多地方，如HDFS，数据库等 1.2 Spark Streaming架构原理 1.2.1 什么是DStream 1.2.2 架构图 整体架构图 SparkStr
Spark Structured Streaming+Kafka+Hbase Scala版-学习笔记
lwb314的专栏
02-22 509
Spark Structured Streaming+Kafka+Hbase Scala版例子前言环境介绍目录第一章 环境搭建 前言 最新在写Spark中间遇到很多坑，在这里总结下来供后来人参考，主要是因为网上的例子真的太少了，而且写的不详细，下边是我集合自己环境以及业务的代码样例。这里只有代码没有环境搭建的内容。 环境介绍 开发工具IDEA 集群环境CDP7.1.4,kafka和Hbase的对应版本后续会具体介绍 语言Scala 目录 第一章 环境搭建 IDEA开发Spark例子,Scala语言版环境搭建
Spark综合学习笔记（十三）SparkStreaming整合Kafka-连接方式和API版本
斯特凡今天也很帅的博客
11-24 8013
学习致谢; https://www.bilibili.com/video/BV1Xz4y1m7cv?p=48 介绍 在实际项目中，无论使用Storm还是SparkStreaming与Flink，主要从Kafka实时消费数据进行处理分析，流式数据实时处理技术架构大致如下: SparkStreaming+Kafka流程 流式数据----->(Flume)----->Kafka------>SparkStreaming/StructStreaming/Flink------>Redis/
【Spark Streaming】Spark Day10：Spark Streaming 学习笔记
Maynor的博客
11-28 1133
Spark Day10：Spark Streaming 01-[了解]-昨日课程内容回顾 ​ 实战练习：以DMP广告行业背景为例，处理广告点击数据，分为2个方面【广告数据ETL转换和业务报表开发】，具体说明如下： 【前提】：使用SparkSQL完成案例练习，进行代码编写 1、广告数据ETL转换 JSON文本数据 -> DataFrame：提取IP地址，解析转换为省份和城市 -> 保存到Hive分区表中 数据源 文件系统（HDFS、LocalFS）文本文件数据：JSON格式
RoadOfStudySpark:Spark 学习之路，包含 Spark Core，Spark SQL，Spark Streaming，Spark mllib 学习笔记
05-09
《Spark学习之旅：Spark Core、Spark SQL、Spark Streaming与Spark MLlib深度解析》 Spark作为大数据处理领域的重要框架，以其高效、易用和模块化的设计赢得了广泛的赞誉。本资料集"RoadOfStudySpark"深入探讨了...
spark笔记整理文档
01-18
与Hadoop MapReduce相比，Spark通过内存计算显著提升了迭代算法的执行效率，同时支持多种数据处理模型，包括批处理、交互式查询（Spark SQL）、流处理（Spark Streaming）和机器学习（MLlib）。 2. Spark核心组件：...
spark学习文档.rar
12-09
总之，"spark学习文档.rar"中的笔记将帮助你深入理解Spark Streaming和Spark SQL，从而能够构建和运行高效的大数据实时处理和分析解决方案。通过系统地学习和实践，你将能够熟练地运用Spark解决各种复杂的数据问题。
go语言里怎么使用kafka怎么拉取消息?
琳琳的博客
06-28 485
在 Go 语言中，你可以使用第三方库如 `segmentio/kafka-go` 或 `Shopify/sarama` 来与 Kafka 进行交互。- 在上面的代码中，我没有包含偏移量提交的示例，因为 `kafka-go` 客户端库会根据配置自动处理偏移量（如果配置为自动提交）。- `MinBytes` 和 `MaxBytes` 是控制从 Kafka 拉取消息大小的参数，你可以根据需要进行调整。- 主题（`topic`）和消费者组（`groupID`）需要根据你的 Kafka 配置进行替换。
Kafka-Produce客户端源码流程
最新发布
qq_35040959的博客
07-01 601
KafkaProducer中会起一个Sender线程，Sender线程中主要有两个方法：sendProducerData()和client.poll()。sendProducerData()负责准备数据并将数据set到通道中等待发送，client.poll()负责真正执行网络的io操作，在每次poll操作中必定有3次发送事件（假设集群中有3个kafka，生产者客户端会分别和3个kafka建立3个通道，这也是每次setSend不会失败的原因，如果失败了则该通道就关闭了）以及若干的接收响应事件。
Spring Boot与Apache Kafka的深度集成
weixin_44626980的博客
06-27 521
大家好，我是免费搭建查券返利机器人省钱赚佣金就用微赚淘客系统3.0的小编，也是冬天不穿秋裤，天冷也要风度的程序猿！今天我们将探讨如何在Spring Boot应用中实现与Apache Kafka的深度集成，利用其强大的消息传递能力来构建高效可靠的分布式系统。
kafka + sparkstreaming 学习笔记
06-28
### 回答1： Kafka和Spark Streaming是大数据领域中非常重要的技术，它们可以协同工作，实现实时数据处理和分析。Kafka是一个分布式的消息队列系统，可以高效地处理海量数据流，而Spark Streaming则是一个基于Spark的流处理框架，可以实现实时数据处理和分析。在学习Kafka和Spark Streaming时，需要掌握它们的基本概念、原理和使用方法，以及如何将它们结合起来实现实时数据处理和分析。同时，还需要了解Kafka和Spark Streaming的优缺点，以及如何优化它们的性能和可靠性。 ### 回答2： Kafka是一个高性能，可扩展的分布式消息系统。它通过将消息划分成一个或多个主题，然后将这些主题划分成一个或多个分区来进行实现。Kafka是由LinkedIn开发的，由Apache基金会进行管理。它的主要设计目标是支持分布式处理，如流处理和批处理等。Kafka通过使用Zookeeper来进行节点管理和故障转移，能够快速处理海量的数据。Kafka采用发布/订阅模式，支持多个消费者订阅同一个主题，每个消费者可以读取主题的所有分区数据，也可以选择读取其中的某个分区。 Spark Streaming是一个流处理框架，它能够利用Spark的分布式处理能力来对实时数据进行处理。Spark Streaming采用微批处理的方式，将实时数据流切片成一段一段的，并通过并行处理的方式进行计算。Spark Streaming的数据源可以是Kafka、Flume或者TCP sockets等。与Kafka相比，Spark Streaming更适合于需要进行实时计算的场景，例如：实时日志分析、实时推荐、实时风控等。同时，Spark Streaming还能够与Spark的批处理进行无缝对接，实现流处理与批处理的统一计算引擎。Spark Streaming支持机器学习、图计算等高级计算库，能够为用户提供更强大的计算能力。 学习Kafka和Spark Streaming的过程中，需要掌握Java、Scala等编程语言基础知识，并具备分布式系统的相关知识。对于Kafka，需要了解其基本概念、架构、API等，理解消息系统、发布/订阅模式、分区等内容。对于Spark Streaming，需要掌握其基本概念、流式计算流程、数据源等，同时也要熟悉Spark的RDD、DataFrame等相关知识。在学习中，需要结合实际项目，进行代码实践和调试，同时不断学习、思考和总结，以加深对Kafka和Spark Streaming的理解和应用。 ### 回答3： Kafka是由Apache SoftWare Foundation开发的一种分布式发布/订阅消息系统。其主要目的是为数据传输提供一种高吞吐量、低延迟的解决方案。Kafka提供了一种可靠的、持久化的、实时的数据传输方式，适用于众多的场景，如：日志收集、数据传输、消息系统等。 Kafka的特点： 1、高吞吐量：Kafka可以支持非常高的数据传输吞吐量，同时保持低延迟和高稳定性。 2、可扩展性：Kafka可以轻松扩展以适应更大的数据需求，并可以在运行时添加新的主题分区。 3、持久化：Kafka保证数据能够可靠地在分布式集群中传输，同时保证数据不会丢失或者被意外删除。 4、多样化的客户端：Kafka提供了多种语言的客户端接口，以满足不同的开发需求。 SparkStreaming 是由Apache Spark社区发展的一个实时数据处理框架。它用于将实时数据流分成小批处理，可以跨越不同的时间窗口进行计算。Spark Streaming提供了与Spark非常相似的编程模型，同时支持不同的输入源，包括社交媒体、传感器、消息队列等。 SparkStreaming的特点： 1、处理速度快：它可以支持毫秒级别的处理速度，并且可以在分布式系统中实现高吞吐量。 2、支持多种数据源：Spark Streaming可以从多种类型的数据源中读取数据，如HDFS、Flume、Kafka等。 3、编程简单：Spark Streaming提供了与Spark相似的编程模式，使得开发人员可以将Spark Streaming与Spark整合在一起进行处理。 4、高容错性：Spark Streaming在分布式环境中实现了高可靠性和容错性，使得它可以支持大规模的实时数据处理需求。 总之，Kafka和Spark Streaming这两个工具是在大数据处理领域中非常重要的工具。它们可以很好地相互结合，支持大规模的实时数据处理和分析，进而为企业提供更好更快的数据处理方案。如果你对这两个技术感兴趣，可以从官方文档和教程开始学习，逐步掌握它们的定义、特点、应用场景和基本使用方法。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值