Question

我正在尝试基于结构化流将基于RDD（从their documentation）迁移到其新的Datasets API的当前流应用，我被告知这是实时进行的首选方法这些天通过Spark进行流媒体播放。

当前，我有一个应用程序设置要使用一个名为“ SATELLITE”的主题，该主题的消息包含关键时间戳记，值包含Satellite POJO。但是我在解决如何实现解串器方面遇到问题。在我当前的应用中，这很容易，您只需在像kafka属性映射kafkaParams.put("value.deserializer", SatelliteMessageDeserializer.class);中添加一条线我正在用Java来做这件事，这是最大的挑战，因为所有解决方案似乎都在Scala中，对此我不太了解，而且我不容易将Scala代码转换为Java代码。

我遵循了this question中概述的JSON示例，该示例目前有效，但是对于我需要做的事情来说似乎过于复杂。鉴于我已经为此目的定制了反序列化器，所以我不明白为什么我必须首先将其转换为字符串，而只是将其转换为JSON，然后再将其转换为所需的类类型。我也一直尝试使用我发现的here示例，但到目前为止我还没有运气。

当前我的应用程序如下所示（使用json方法）：

import common.model.Satellite;
import org.apache.spark.sql.*;
import org.apache.spark.sql.streaming.StreamingQueryException;
import org.apache.spark.sql.types.DataTypes;
import org.apache.spark.sql.types.StructField;
import org.apache.spark.sql.types.StructType;

public class SparkStructuredStreaming  implements Runnable{

    private String bootstrapServers;
    private SparkSession session;

    public SparkStructuredStreaming(final String bootstrapServers, final SparkSession session) {
        this.bootstrapServers = bootstrapServers;
        this.session = session;
    }
    @Override
    public void run() {
        Dataset<Row> df = session
                .readStream()
                .format("kafka")
                .option("kafka.bootstrap.servers", bootstrapServers)
                .option("subscribe", "SATELLITE")
                .load();

        StructType schema =  DataTypes.createStructType(new StructField[] {
                DataTypes.createStructField("id", DataTypes.StringType, true),
                DataTypes.createStructField("gms", DataTypes.StringType, true),
                DataTypes.createStructField("satelliteId", DataTypes.StringType, true),
                DataTypes.createStructField("signalId", DataTypes.StringType, true),
                DataTypes.createStructField("cnr", DataTypes.DoubleType, true),
                DataTypes.createStructField("constellation", DataTypes.StringType, true),
                DataTypes.createStructField("timestamp", DataTypes.TimestampType, true),
                DataTypes.createStructField("mountPoint", DataTypes.StringType, true),
                DataTypes.createStructField("pseudorange", DataTypes.DoubleType, true),
                DataTypes.createStructField("epochTime", DataTypes.IntegerType, true)
        });

            Dataset<Satellite> df1 = df.selectExpr("CAST(value AS STRING) as message")
                    .select(functions.from_json(functions.col("message"),schema).as("json"))
                    .select("json.*")
                    .as(Encoders.bean(Satellite.class));

        try {
            df1.writeStream()
                    .format("console")
                    .option("truncate", "false")
                    .start()
                    .awaitTermination();

        } catch (StreamingQueryException e) {
            e.printStackTrace();
        }
    }
}

我有一个自定义的反序列化器，看起来像这样

import common.model.Satellite;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.kafka.common.serialization.Deserializer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.Map;

public class SatelliteMessageDeserializer implements Deserializer<Satellite> {

    private static Logger logger = LoggerFactory.getLogger(SatelliteMessageDeserializer.class);
    private ObjectMapper objectMapper = new ObjectMapper();

    @Override
    public void configure(Map configs, boolean isKey) {
    }

    @Override
    public void close() {
    }

    @Override
    public Satellite deserialize(String topic, byte[] data) {
        try {
            return objectMapper.readValue(new String(data, "UTF-8"), getMessageClass());
        } catch (Exception e) {
            logger.error("Unable to deserialize message {}", data, e);
            return null;
        }
    }

    protected Class<Satellite> getMessageClass() {
        return Satellite.class;
    }
}

如何在SparkStructuredStreaming类中使用自定义解串器？我正在使用Spark 2.4，OpenJDK 10和Kafka 2.0

编辑：我尝试创建自己的UDF，我认为应该这样做，但是我不确定如何使它返回特定类型，因为它似乎只允许我执行以下操作：使用Datatypes类中的那些！

UserDefinedFunction mode = udf(
                (byte[] bytes) -> deserializer.deserialize("", bytes), DataTypes.BinaryType //Needs to be type Satellite, but only allows ones of type DataTypes
        );

Dataset df1 = df.select(mode.apply(col("value")));

Answer 1

from_json仅适用于字符串类型的列。

Structured Streaming always consumes the Kafka values as bytes

始终使用ByteArrayDeserializer将值反序列化为字节数组。使用DataFrame操作显式反序列化值

因此，您首先至少要反序列化为String，但我认为您并不是真的需要。

也许可以这样做

df.select(value).as(Encoders.bean(Satellite.class))

如果这不起作用，您可以尝试定义自己的UDF / Decoder，这样您就可以使用SATELLITE_DECODE(value)

在Scala中

object SatelliteDeserializerWrapper {
    val deser = new SatelliteDeserializer
}
spark.udf.register("SATELLITE_DECODE", (topic: String, bytes: Array[Byte]) => 
    SatelliteDeserializerWrapper.deser.deserialize(topic, bytes)
)

df.selectExpr("""SATELLITE_DECODE("topic1", value) AS message""")

请参见this post for inspiration，也提到了in Databricks blog

如何使用Spark结构化流为Kafka流实现自定义反序列化器？

1 个答案: