java如何拿到spark实时数据

在Java中获取Spark实时数据，可以使用Spark Streaming、Structured Streaming、Kafka等技术。以下是一种详细方法：使用Spark Streaming与Kafka结合。

Spark Streaming是一种实时数据处理框架，它可以从多种数据源（如Kafka、Flume、Kinesis等）获取数据并进行处理。Kafka是一种高吞吐量、分布式消息系统，适用于实时数据流处理。使用这两者结合，可以实现Java中获取Spark实时数据。下面将详细介绍这种方法。

一、设置环境

在开始编写代码之前，确保你已经设置好开发环境。你需要以下工具和库：

Apache Kafka：消息系统，用于存储和传输数据流。
Apache Spark：用于数据处理的分布式计算框架。
Java Development Kit (JDK)：Java开发工具包。
Maven或Gradle：项目管理工具，用于管理依赖。

1.1、安装Kafka

下载并解压Kafka：

wget http://www-eu.apache.org/dist/kafka/2.8.0/kafka_2.13-2.8.0.tgz tar -xzf kafka_2.13-2.8.0.tgz cd kafka_2.13-2.8.0

启动ZooKeeper和Kafka服务：

# 启动ZooKeeper bin/zookeeper-server-start.sh config/zookeeper.properties 启动Kafka bin/kafka-server-start.sh config/server.properties

1.2、创建Kafka主题

创建一个用于测试的Kafka主题：

bin/kafka-topics.sh --create --topic test-topic --bootstrap-server localhost:9092 --replication-factor 1 --partitions 1

1.3、创建Maven项目

创建一个新的Maven项目并添加以下依赖到pom.xml文件中：

<dependencies>
    <dependency>
        <groupId>org.apache.spark</groupId>
        <artifactId>spark-core_2.12</artifactId>
        <version>3.1.1</version>
    </dependency>
    <dependency>
        <groupId>org.apache.spark</groupId>
        <artifactId>spark-streaming_2.12</artifactId>
        <version>3.1.1</version>
    </dependency>
    <dependency>
        <groupId>org.apache.spark</groupId>
        <artifactId>spark-streaming-kafka-0-10_2.12</artifactId>
        <version>3.1.1</version>
    </dependency>
</dependencies>

二、编写Java代码

2.1、创建Spark Streaming上下文

首先，创建一个Java类，并设置Spark Streaming上下文：

import org.apache.spark.SparkConf;
import org.apache.spark.streaming.Durations;
import org.apache.spark.streaming.api.java.JavaStreamingContext;
public class SparkKafkaConsumer {
    public static void main(String[] args) {
        SparkConf conf = new SparkConf().setAppName("KafkaSparkStreaming").setMaster("local[*]");
        JavaStreamingContext jssc = new JavaStreamingContext(conf, Durations.seconds(10));
        // 其他代码
    }
}

2.2、配置Kafka参数

设置Kafka参数，并创建输入DStream：

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.common.serialization.StringDeserializer;
import org.apache.spark.streaming.api.java.JavaInputDStream;
import org.apache.spark.streaming.kafka010.ConsumerStrategies;
import org.apache.spark.streaming.kafka010.KafkaUtils;
import org.apache.spark.streaming.kafka010.LocationStrategies;
public class SparkKafkaConsumer {
    public static void main(String[] args) {
        SparkConf conf = new SparkConf().setAppName("KafkaSparkStreaming").setMaster("local[*]");
        JavaStreamingContext jssc = new JavaStreamingContext(conf, Durations.seconds(10));
        Map<String, Object> kafkaParams = new HashMap<>();
        kafkaParams.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
        kafkaParams.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        kafkaParams.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        kafkaParams.put(ConsumerConfig.GROUP_ID_CONFIG, "spark-group");
        kafkaParams.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "latest");
        kafkaParams.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, false);
        JavaInputDStream<ConsumerRecord<String, String>> stream = KafkaUtils.createDirectStream(
                jssc,
                LocationStrategies.PreferConsistent(),
                ConsumerStrategies.Subscribe(Collections.singletonList("test-topic"), kafkaParams)
        );
        // 其他代码
    }
}

2.3、处理Kafka数据

处理从Kafka获取的数据：

import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.spark.api.java.function.VoidFunction;
import org.apache.spark.streaming.api.java.JavaDStream;
public class SparkKafkaConsumer {
    public static void main(String[] args) {
        SparkConf conf = new SparkConf().setAppName("KafkaSparkStreaming").setMaster("local[*]");
        JavaStreamingContext jssc = new JavaStreamingContext(conf, Durations.seconds(10));
        Map<String, Object> kafkaParams = new HashMap<>();
        kafkaParams.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
        kafkaParams.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        kafkaParams.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        kafkaParams.put(ConsumerConfig.GROUP_ID_CONFIG, "spark-group");
        kafkaParams.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "latest");
        kafkaParams.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, false);
        JavaInputDStream<ConsumerRecord<String, String>> stream = KafkaUtils.createDirectStream(
                jssc,
                LocationStrategies.PreferConsistent(),
                ConsumerStrategies.Subscribe(Collections.singletonList("test-topic"), kafkaParams)
        );
        JavaDStream<String> lines = stream.map(ConsumerRecord::value);
        lines.foreachRDD((VoidFunction<JavaRDD<String>>) rdd -> {
            if (!rdd.isEmpty()) {
                rdd.collect().forEach(System.out::println);
            }
        });
        jssc.start();
        jssc.awaitTermination();
    }
}

三、运行程序

在终端中运行你的Java程序。你将看到从Kafka主题中读取的实时数据输出到控制台。

3.1、发送测试数据到Kafka

在另一个终端中，启动Kafka生产者并发送一些测试数据：

bin/kafka-console-producer.sh --topic test-topic --bootstrap-server localhost:9092

输入一些数据并按Enter键，你将在运行Java程序的控制台中看到这些数据。

3.2、监控和调试

在实际应用中，你可以通过日志、监控工具（如Prometheus和Grafana）来监控和调试你的Spark Streaming应用。

通过上述步骤，你可以在Java中使用Spark Streaming和Kafka实现实时数据处理。这种方法具有高吞吐量、低延迟、易扩展的优势，适用于各种实时数据处理场景。