spark streaming(非structured steaming)消费rocketMQ，并手动提交

一、背景

最近有一个需求是：要求有一个类对象为Order，它有string类型的字段orderNo和Long类型的字段cost，生产者写到rocketMQ的value是Order对象序列化后的字节数组、key值是orderNo字段，要求spark以手动提交的方式消费rocketMQ，并将数据依次写入到hive表中，并且spark中有一个5分钟滑动窗口，滑动步长为1分钟，统计5分钟内的cost总值并输出。

 

二、实战演练

RocketMQ 官方并没有像 Kafka 那样的「Spark DirectStream 一键式手动提交 offset」通用方案；因此我用的是一种常见的、工程可控的做法来实现“手动提交 offset”语义：

• 使用 Spark Streaming (DStream)（不是 Structured Streaming，因为你明确要手动提交 offset；Structured Streaming 的 offset 管理是自动的，不能手动提交）。

• 我实现了一个 自定义 Receiver（RocketMQReceiver），该 Receiver 在每个 batch 周期从 RocketMQ 拉取消息（Pull 模式），并把 Order 对象推入 DStream。

• 手动提交 offset 的实现：Receiver 不把 offset 自动永久化到 Broker，而是把“当前读取到的 offset”存放在一个外部可共享位置（示例使用 HDFS/local 文件作为简单的 offset store）。Driver 在确认该 batch 的 RDD 已成功写入 Hive 后，会把“该 batch 已处理的 offsets”写回到同一 offset store（即手动提交）。下一次 Receiver 启动 / 拉取时，会从 offset store 读取这些已提交的 offsets 继续拉取。

  这种方案与 Kafka 的 commitAsync 思路等价：只有当你确认完成写入（输出）后，才把 offset 持久化（提交）。该方法是通用的、工程上常用的“外部 offset 管理”策略，能满足“手动提交”需求。

下面包含：pom.xml、Order.java、RocketMQ 生产者 OrderProducer.java、Hive 建表 SQL、Spark 程序 SparkRocketMQToHive.java（包含自定义 Receiver、window 逻辑与手动 offset 提交），以及运行说明与注意事项。

1) pom.xml（主要依赖）

<project xmlns="http://maven.apache.org/POM/4.0.0" >
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.example</groupId>
  <artifactId>spark-rocketmq-hive-demo</artifactId>
  <version>1.0-SNAPSHOT</version>
  <properties>
    <java.version>1.8</java.version>
    <scala.version>2.12</scala.version>
    <spark.version>3.3.2</spark.version>
    <rocketmq.version>4.9.4</rocketmq.version>
  </properties>
  <dependencies>
    <!-- Spark -->
    <dependency>
      <groupId>org.apache.spark</groupId>
      <artifactId>spark-core_2.12</artifactId>
      <version>${spark.version}</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>org.apache.spark</groupId>
      <artifactId>spark-streaming_2.12</artifactId>
      <version>${spark.version}</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>org.apache.spark</groupId>
      <artifactId>spark-sql_2.12</artifactId>
      <version>${spark.version}</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>org.apache.spark</groupId>
      <artifactId>spark-hive_2.12</artifactId>
      <version>${spark.version}</version>
      <scope>provided</scope>
    </dependency>

    <!-- RocketMQ client (producer & pull consumer) -->
    <dependency>
      <groupId>org.apache.rocketmq</groupId>
      <artifactId>rocketmq-client</artifactId>
      <version>${rocketmq.version}</version>
    </dependency>

    <!-- Logging -->
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <version>1.7.36</version>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-log4j12</artifactId>
      <version>1.7.36</version>
    </dependency>
  </dependencies>
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.8.1</version>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

2) Hive 建表 SQL

在 Hive CLI 或 Hue 执行：

CREATE DATABASE IF NOT EXISTS demo_db;

-- 原始订单表，包含事件时间 ts（毫秒）
CREATE TABLE IF NOT EXISTS demo_db.orders (
  orderNo STRING,
  cost BIGINT,
  ts BIGINT
)
STORED AS PARQUET;

-- 窗口聚合表
CREATE TABLE IF NOT EXISTS demo_db.order_cost_window_agg (
  window_start TIMESTAMP,
  window_end TIMESTAMP,
  total_cost BIGINT
)
STORED AS PARQUET;

3) Order 类（Order.java）

package com.example;

import java.io.Serializable;

public class Order implements Serializable {
    private static final long serialVersionUID = 1L;

    private String orderNo;
    private Long cost;
    private Long ts; // 事件时间，毫秒

    public Order() {}

    public Order(String orderNo, Long cost, Long ts) {
        this.orderNo = orderNo;
        this.cost = cost;
        this.ts = ts;
    }

    public String getOrderNo() { return orderNo; }
    public void setOrderNo(String orderNo) { this.orderNo = orderNo; }

    public Long getCost() { return cost; }
    public void setCost(Long cost) { this.cost = cost; }

    public Long getTs() { return ts; }
    public void setTs(Long ts) { this.ts = ts; }

    @Override
    public String toString() {
        return "Order{" + "orderNo='" + orderNo + '\'' + ", cost=" + cost + ", ts=" + ts + '}';
    }
}

序列化方案：示例使用 Java 原生序列化（ObjectOutputStream → byte[]）。生产环境建议改为 JSON/Avro/ProtoBuf。

4) RocketMQ 生产者示例（OrderProducer.java）

package com.example;

import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.common.message.Message;

import java.io.ByteArrayOutputStream;
import java.io.ObjectOutputStream;
import java.util.UUID;

public class OrderProducer {
    public static byte[] serialize(Order order) throws Exception {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(order);
        oos.flush();
        return bos.toByteArray();
    }

    public static void main(String[] args) throws Exception {
        String namesrvAddr = "localhost:9876"; // 修改为你的nameserver地址
        String topic = "orders-topic";

        DefaultMQProducer producer = new DefaultMQProducer("order-producer-group");
        producer.setNamesrvAddr(namesrvAddr);
        producer.start();

        for (int i = 0; i < 50; i++) {
            String orderNo = "ORD-" + UUID.randomUUID().toString().substring(0, 8);
            long cost = (long)(Math.random() * 1000);
            long ts = System.currentTimeMillis();

            Order order = new Order(orderNo, cost, ts);
            byte[] body = serialize(order);

            Message msg = new Message(topic, "tagA", orderNo, body);
            producer.send(msg); // 同步发送
            System.out.println("Sent: " + order);
            Thread.sleep(200);
        }

        producer.shutdown();
    }
}

5) Spark 程序（完整）：SparkRocketMQToHive.java

主要思路：

• 自定义 RocketMQReceiver extends Receiver<Order>：在 onStart 启动一个拉取线程，周期性从 RocketMQ 的每个 MessageQueue 拉取消息（从我们持久化的 offset store 开始），并 store(order) 推送给 Spark Streaming。

• offset store：示例用一个简单的文件（可以是 HDFS 路径）保存 JSON 格式的已提交 offsets（per-queue）。

• Driver 端的 foreachRDD 会把 RDD 写入 Hive（append），并且在成功写入后把该 batch 的最大 offsets 写入 offset store（即手动提交）。

• 窗口聚合：用 DStream 的 window(Durations.minutes(5), Durations.minutes(1))，在每个窗口上做 map(Order->("all", cost)) reduce，最后写入聚合表。

注意：代码做了较多注释，请按注释中的 TODO 修改 RocketMQ namesrv、topic、以及 offsetStorePath（HDFS 路径建议用 hdfs://...）。

package com.example;

import org.apache.hadoop.fs.*;
import org.apache.hadoop.conf.Configuration;
import org.apache.rocketmq.client.consumer.DefaultMQPullConsumer;
import org.apache.rocketmq.client.consumer.PullResult;
import org.apache.rocketmq.client.consumer.PullStatus;
import org.apache.rocketmq.common.message.MessageExt;
import org.apache.rocketmq.common.message.MessageQueue;
import org.apache.spark.SparkConf;
import org.apache.spark.api.java.*;
import org.apache.spark.streaming.*;
import org.apache.spark.streaming.api.java.*;
import org.apache.spark.streaming.receiver.Receiver;
import org.apache.spark.storage.StorageLevel;
import org.apache.spark.sql.*;

import java.io.*;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;

import scala.Tuple2;

public class SparkRocketMQToHive {

    // -------------------------
    // OffsetStore: 通过文件（HDFS/local）保存已提交 offsets（简单实现）
    // 存储格式（简单 JSON-like）:
    // queueId|brokerName|queueOffset\n
    // -------------------------
    public static class OffsetStore {
        private final String path; // e.g., hdfs://namenode:8020/user/offsets/orders_offsets.txt or file:///tmp/...
        private final Configuration hadoopConf = new Configuration();

        public OffsetStore(String path) {
            this.path = path;
        }

        // 读取已提交 offsets -> Map<MessageQueue, Long>
        public Map<MessageQueue, Long> readOffsets() throws IOException {
            Map<MessageQueue, Long> map = new HashMap<>();
            Path p = new Path(path);
            FileSystem fs = p.getFileSystem(hadoopConf);
            if (!fs.exists(p)) return map;

            try (FSDataInputStream in = fs.open(p);
                 BufferedReader br = new BufferedReader(new InputStreamReader(in))) {
                String line;
                while ((line = br.readLine()) != null) {
                    // 格式: brokerName|queueId|offset
                    String[] parts = line.trim().split("\\|");
                    if (parts.length == 3) {
                        String broker = parts[0];
                        int queueId = Integer.parseInt(parts[1]);
                        long offset = Long.parseLong(parts[2]);
                        // MessageQueue requires topic too — we will reconstruct with topic externally
                        // To simplify, we return map keyed by "broker:queueId" in caller
                        MessageQueue mq = new MessageQueue(); // placeholder, set fields later
                        mq.setBrokerName(broker);
                        mq.setQueueId(queueId);
                        // cannot set topic here; caller will match based on broker+queueId.
                        map.put(mq, offset);
                    }
                }
            } catch (Exception e) {
                throw new IOException("readOffsets failed", e);
            }
            return map;
        }

        // 简化写入：由 caller 提供 list of entries (broker|queueId|offset)
        public void writeOffsets(List<String> lines) throws IOException {
            Path p = new Path(path);
            FileSystem fs = p.getFileSystem(hadoopConf);
            // 覆盖写入
            try (FSDataOutputStream out = fs.create(p, true);
                 BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(out))) {
                for (String line : lines) {
                    bw.write(line);
                    bw.newLine();
                }
            }
        }
    }

    // -------------------------
    // RocketMQReceiver：自定义 Receiver，从 RocketMQ pull 消息并 store()
    // -------------------------
    public static class RocketMQReceiver extends Receiver<Order> {
        private volatile boolean stopped = false;
        private final String namesrvAddr;
        private final String topic;
        private final String consumerGroup;
        private final String offsetStorePath; // offset store path
        private transient DefaultMQPullConsumer pullConsumer;

        // local map to hold the latest pulled offsets per MessageQueue
        private final Map<MessageQueue, Long> latestPulledOffsets = new ConcurrentHashMap<>();

        public RocketMQReceiver(String namesrvAddr, String topic, String consumerGroup, String offsetStorePath) {
            super(StorageLevel.MEMORY_AND_DISK_2());
            this.namesrvAddr = namesrvAddr;
            this.topic = topic;
            this.consumerGroup = consumerGroup;
            this.offsetStorePath = offsetStorePath;
        }

        @Override
        public void onStart() {
            stopped = false;
            // start pulling thread
            new Thread(this::pullLoop, "rocketmq-pull-thread").start();
        }

        @Override
        public void onStop() {
            stopped = true;
            if (pullConsumer != null) {
                try {
                    pullConsumer.shutdown();
                } catch (Exception ignored) {
                }
            }
        }

        private void pullLoop() {
            try {
                pullConsumer = new DefaultMQPullConsumer(consumerGroup + "_pull");
                pullConsumer.setNamesrvAddr(namesrvAddr);
                pullConsumer.start();

                // 获取所有 message queues for topic
                Set<MessageQueue> mqs = pullConsumer.fetchSubscribeMessageQueues(topic);

                // 读取已提交 offsets（从 offset store）
                Map<MessageQueue, Long> committed = readOffsetStore();

                while (!stopped) {
                    for (MessageQueue mq : mqs) {
                        long offset = 0L;
                        // find committed offset matching same broker+queueId
                        Optional<Map.Entry<MessageQueue, Long>> found = committed.entrySet().stream()
                                .filter(e -> e.getKey().getBrokerName().equals(mq.getBrokerName())
                                        && e.getKey().getQueueId() == mq.getQueueId())
                                .findFirst();
                        if (found.isPresent()) offset = found.get().getValue();
                        // Pull
                        try {
                            PullResult pullResult = pullConsumer.pullBlockIfNotFound(mq, null, offset, 32);
                            if (pullResult != null) {
                                if (pullResult.getPullStatus() == PullStatus.FOUND) {
                                    List<MessageExt> msgs = pullResult.getMsgFoundList();
                                    if (msgs != null) {
                                        for (MessageExt me : msgs) {
                                            try {
                                                byte[] body = me.getBody();
                                                Order o = deserialize(body);
                                                if (o != null) {
                                                    store(o); // 推入 DStream
                                                }
                                            } catch (Exception e) {
                                                // log and continue
                                                e.printStackTrace();
                                            }
                                        }
                                    }
                                }
                                // 更新本地 latestPulledOffsets：下次从 pullResult.getNextBeginOffset() 拉
                                long nextOffset = pullResult.getNextBeginOffset();
                                latestPulledOffsets.put(mq, nextOffset);
                            }
                        } catch (Exception ex) {
                            ex.printStackTrace();
                        }
                        if (stopped) break;
                    }
                    // 拉完一轮 messageQueues 之后，短睡眠一下，等待下一 batch 拉取
                    Thread.sleep(500);
                }
            } catch (Exception e) {
                e.printStackTrace();
                restart("rocketmq pull failed", e);
            }
        }

        // 从 offset store 读取已提交 offsets（简化）
        private Map<MessageQueue, Long> readOffsetStore() {
            OffsetStore store = new OffsetStore(offsetStorePath);
            try {
                return store.readOffsets();
            } catch (Exception e) {
                // log and return empty
                e.printStackTrace();
                return new HashMap<>();
            }
        }

        // 反序列化 Order（Java 原生序列化）
        private Order deserialize(byte[] bytes) {
            if (bytes == null) return null;
            try (ByteArrayInputStream bis = new ByteArrayInputStream(bytes);
                 ObjectInputStream ois = new ObjectInputStream(bis)) {
                return (Order) ois.readObject();
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }

        // 提供外部访问最新 pulled offsets 的方法（driver 可以读取并在处理完写入后提交）
        public Map<MessageQueue, Long> getLatestPulledOffsets() {
            return new HashMap<>(latestPulledOffsets);
        }
    }

    // -------------------------
    // 主程序：Spark Streaming 作业
    // -------------------------
    public static void main(String[] args) throws Exception {
        // config
        String namesrv = "localhost:9876"; // TODO 修改
        String topic = "orders-topic";
        String consumerGroup = "spark-rocketmq-group";
        String offsetStorePath = "file:///tmp/rocketmq_offsets.txt"; // TODO 改为 HDFS 路径：hdfs://namenode:8020/user/offsets/orders_offsets.txt

        SparkConf conf = new SparkConf()
                .setAppName("SparkRocketMQToHive")
                .setIfMissing("spark.master", "local[2]")
                .set("spark.serializer", "org.apache.spark.serializer.KryoSerializer");

        // batch interval = 1 minute (符合滑动步长)
        JavaStreamingContext jssc = new JavaStreamingContext(conf, Durations.minutes(1));
        // checkpoint dir for Spark Streaming state (if needed)
        jssc.checkpoint("/tmp/spark-streaming-checkpoint");

        // 创建并注册 Receiver
        RocketMQReceiver receiver = new RocketMQReceiver(namesrv, topic, consumerGroup, offsetStorePath);
        JavaReceiverInputDStream<Order> stream = jssc.receiverStream(receiver);

        // 将原始 order 写入 Hive（每个 micro-batch 的 RDD）
        stream.foreachRDD((JavaRDD<Order> rdd, Time time) -> {
            if (rdd.isEmpty()) {
                System.out.println("No data in this batch: " + time);
                return;
            }

            // 创建 SparkSession（在 executor 上创建会出问题，因此在 driver 上操作）
            SparkSession spark = SparkSession.builder()
                    .config(conf)
                    .enableHiveSupport()
                    .getOrCreate();

            Dataset<Row> df = spark.createDataFrame(rdd, Order.class);
            // 写入 orders 表（append）
            df.write().mode(SaveMode.Append).insertInto("demo_db.orders");

            System.out.println("Wrote batch to Hive: " + time + ", count=" + rdd.count());

            // 手动提交 offset：从 receiver 获取 latestPulledOffsets，然后把它持久化到 offsetStorePath（覆盖写）
            Map<MessageQueue, Long> latestOffsets = receiver.getLatestPulledOffsets();
            List<String> lines = latestOffsets.entrySet().stream()
                    .map(e -> e.getKey().getBrokerName() + "|" + e.getKey().getQueueId() + "|" + e.getValue())
                    .collect(Collectors.toList());
            OffsetStore store = new OffsetStore(offsetStorePath);
            store.writeOffsets(lines);
            System.out.println("Committed offsets for this batch: " + lines);
        });

        // 窗口聚合：5 分钟窗口，1 分钟滑动，统计 cost 总和
        JavaPairDStream<String, Long> kv = stream.mapToPair(order -> new Tuple2<>("all", order.getCost() == null ? 0L : order.getCost()));
        JavaPairDStream<String, Long> windowed = kv.reduceByKeyAndWindow((a, b) -> a + b,
                Durations.minutes(5), Durations.minutes(1));

        // 每个窗口写入聚合表
        windowed.foreachRDD((rdd, time) -> {
            if (rdd.isEmpty()) return;
            SparkSession spark = SparkSession.builder().config(conf).enableHiveSupport().getOrCreate();

            final long windowEndMs = time.milliseconds();
            final long windowStartMs = windowEndMs - 5 * 60 * 1000 + 1;

            List<Row> rows = rdd.map(tuple -> RowFactory.create(new java.sql.Timestamp(windowStartMs),
                    new java.sql.Timestamp(windowEndMs), tuple._2())).collect();

            StructType schema = new StructType(new StructField[]{
                    new StructField("window_start", DataTypes.TimestampType, false, Metadata.empty()),
                    new StructField("window_end", DataTypes.TimestampType, false, Metadata.empty()),
                    new StructField("total_cost", DataTypes.LongType, false, Metadata.empty())
            });

            Dataset<Row> df = spark.createDataFrame(rows, schema);
            df.write().mode(SaveMode.Append).insertInto("demo_db.order_cost_window_agg");
            System.out.println("Wrote window agg: start=" + new java.sql.Timestamp(windowStartMs) + " end=" + new java.sql.Timestamp(windowEndMs));
        });

        // 启动
        jssc.start();
        jssc.awaitTermination();
    }
}

6) 运行步骤（本地测试）

1. 启动 RocketMQ (nameserver + broker)。确保 namesrvAddr 在 producer/consumer/receiver 中一致。

2. 在 Hive 中执行建表 SQL。

3. 用 Maven 打包：

   mvn clean package -DskipTests

4. 先运行 OrderProducer 发送一些消息：

   java -cp target/spark-rocketmq-hive-demo-1.0-SNAPSHOT.jar com.example.OrderProducer

5. 使用 spark-submit 提交 Spark Streaming 作业（注意把 rocketmq-client 的 jar 加到 classpath，或者使用 --packages/--jars）：

   $SPARK_HOME/bin/spark-submit \ --class com.example.SparkRocketMQToHive \ --master local[2] \ --jars path/to/rocketmq-client-4.9.4.jar \ target/spark-rocketmq-hive-demo-1.0-SNAPSHOT.jar

   或把 rocketmq-client 打包进 fat-jar。

6. 观察 Hive 表 demo_db.orders 和 demo_db.order_cost_window_agg 是否有数据。

7) 设计说明与注意事项（必须阅读）

1. 为什么用 Receiver + 外部 offset store？

   • RocketMQ 与 Kafka 在生态、客户端 API 上不同，且没有像 Kafka DirectStream 那样的“offsetRanges 可在 driver 中获取并 commitAsync”现成模式；用 Receiver + 自己维护 offset store（HDFS/file/ZK）可以实现“在确认写入外部 sink 后再提交 offset”这一语义。

2. offset 的一致性

   • 该实现保证：只有在 Spark 确认该 batch 数据已写入 Hive 后，才把最新 pulled offsets 持久化（提交）。若写 Hive 失败，则不会提交 offsets，下次作业重启或 receiver 重新读取时会从上次提交点重新读取（幂等问题需用户在写入时处理，比如去重或使用唯一 key 覆盖写入策略）。

3. OffsetStore 的实现示例简单

   • 示例使用了一个非常简单的文件格式。生产环境建议使用 Zookeeper、HBase、MySQL 或 RocketMQ 的 broker commit 接口（如果可用）来存放 offsets，需要考虑并发/权限/原子写入等问题。使用 HDFS 写入需确保 driver 与 receiver 都能访问同一路径。

4. 性能 & 并发

   • 示例中 receiver 一次拉取固定数量（32 条）并逐条 store()。你可以根据需要调整并行度（多个 receiver 实例、每 queue 的并发拉取、批量 store 等）。另外，window 聚合会把数据在 driver 上合并写入 Hive（请按集群资源调优并行度、分区数等）。

5. 序列化方案

   • 示例使用 Java native serialization（ObjectOutputStream）。生产环境应优先使用 JSON / Avro / Protobuf 以便于兼容与演进。

6. 幂等性

   • 如果你的 Hive 写入不是幂等的（例如重复写会产生重复记录），建议在订单表中使用 orderNo 做主键去重或在写入前做去重。因为若写失败后重试，会产生重复消费。

7. 时间与窗口

   • 示例窗口使用 processing-time（因为 DStream 没有像 Structured Streaming 那样方便的事件时间 watermark）。如果你需要基于 ts（Order 内的事件时间）做更准确的事件时间窗口，并处理乱序数据，建议使用 Structured Streaming（但 Structured Streaming 不允许手动提交 offset）。这两者之间是权衡：事件时间 + watermark（Structured Streaming）VS 可控手动提交 offset（本示例用 DStream + 自管理 offset）。

8) 下步可选改进

• 把 offsetStore 从文件改成 ZooKeeper 实现（更可靠，适合分布式部署）。

• 把序列化改成 JSON（Jackson）：更易于调试和兼容。

• 把 Receiver 的拉取逻辑改成批量化、高吞吐版本（同时按 partition 拉取并做并行 store）。

• 如果你想改用 Structured Streaming（事件时间 + watermark 优势），我可以给出无法手动提交 offset 的替代方案：例如把 Hive 写入做幂等化（基于 orderNo）从而允许使用 Structured Streaming 的自动 offset 管理与 exactly-once 语义。

 

转载请注明出处：https://www.cnblogs.com/fnlingnzb-learner/p/19073689