SpringBoot与Flink集群集成实战:从本地开发到云端部署

SpringBoot与Flink集群部署实战:从本地调试到云端运行的完整指南 本文详细介绍了如何将SpringBoot与Flink集群集成,从本地调试到云端部署的完整流程。通过实战案例展示配置管理、依赖注入和生态整合的优势,提供打包部署的解决方案和性能调优建议,帮助开发者高效实现实时数据处理应用。 阅读详情

1. 为什么要把SpringBoot和Flink“撮合”到一起?

如果你是一个Java开发者,对SpringBoot肯定不陌生,它就像你的瑞士军刀,能快速搭建各种Web应用和微服务。而Flink呢,是当下最火的流处理框架之一,专门对付实时数据,比如监控设备状态、实时风控、双十一大屏。那为啥要把这俩放一块儿?我刚开始做项目的时候也这么想,直接在Flink的main方法里写业务不香吗?

后来踩了几个坑才明白,事情没那么简单。很多公司的业务系统已经是SpringBoot的“天下”了,里面集成了MyBatis、Redis、各种RPC框架,还有一整套成熟的配置管理、依赖注入和事务管理机制。如果为了一个Flink实时任务,就得另起炉灶,重新写一套数据访问层、配置读取逻辑,那简直是重复造轮子,维护成本也高得吓人。更现实的情况是,你的业务逻辑里可能需要调用已有的Spring Bean服务,比如查一下用户信息,或者更新一下数据库里的配置。这时候,在Flink里能直接@Autowired注入一个Service,别提多方便了。

所以,SpringBoot集成Flink的核心诉求就出来了:复用现有的Spring生态能力,让流处理任务的开发像写普通业务代码一样简单。你不用再操心Flink JobManager的生命周期怎么和Spring容器绑定,也不用自己手动管理一堆连接池。想象一下,你的Flink任务能直接读取application.yml里的数据库配置,能优雅地使用@Transactional注解,甚至能通过@Scheduled定时触发一些检查,这种开发体验的提升是巨大的。当然,这条路一开始并不好走,我当初也是被各种类加载器冲突、打包问题折腾得够呛,但趟平之后,你会发现这是一条非常高效的开发路径。

2. 搭建你的第一个SpringBoot+Flink项目

光说不练假把式,咱们直接动手,从零开始搭一个能跑起来的项目。我会把每一步的细节和背后的“为什么”都讲清楚,让你不仅会操作,还能理解原理。

2.1 项目骨架与核心依赖

首先,用你熟悉的IDE(比如IntelliJ IDEA)或者Spring Initializr创建一个标准的SpringBoot项目。我这里用的是SpringBoot 2.3.5.RELEASE,这个版本比较稳定,和Flink 1.13.x的兼容性也经过了很多项目验证。创建时记得选上Spring Web和Lombok(可选,但能省不少代码)。

接下来就是重头戏:pom.xml里的依赖管理。Flink的依赖有个特点,它很多模块的版本号和Scala版本是绑定的。对于Java项目,我们通常用_2.11或_2.12的后缀,这里我建议用_2.11,社区资源更丰富一些。

<properties>
    <flink.version>1.13.1</flink.version>
    <scala.binary.version>2.11</scala.binary.version>
</properties>

<dependencies>
    <!-- SpringBoot基础依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <!-- 关键!排除默认的logback,避免与Flink集群的日志冲突 -->
        <exclusions>
            <exclusion>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-logging</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>

    <!-- Flink核心依赖 -->
    <dependency>
        <groupId>org.apache.flink</groupId>
        <artifactId>flink-java</artifactId>
        <version>${flink.version}</version>
    </dependency>
    <dependency>
        <groupId>org.apache.flink</groupId>
        <artifactId>flink-streaming-java_${scala.binary.version}</artifactId>
        <version>${flink.version}</version>
    </dependency>
    <!-- Flink客户端,用于本地执行和提交作业 -->
    <dependency>
        <groupId>org.apache.flink</groupId>
        <artifactId>flink-clients_${scala.binary.version}</artifactId>
        <version>${flink.version}</version>
    </dependency>

    <!-- 连接器:这里以Kafka为例 -->
    <dependency>
        <groupId>org.apache.flink</groupId>
        <artifactId>flink-connector-kafka_${scala.binary.version}</artifactId>
        <version>${flink.version}</version>
    </dependency>

    <!-- 其他业务依赖,比如MySQL -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.26</version>
    </dependency>
</dependencies>

这里有个超级重要的坑我已经帮你提前避开了:排除了spring-boot-starter-logging。因为SpringBoot默认用Logback,而Flink集群环境通常自带一套日志框架(比如Log4j)。如果你不排除,把打好的包扔到集群上,很可能会看到LoggerFactory is not a Logback LoggerContext but Logback is on the classpath这种让人头疼的报错。所以,这一步千万不能省。

2.2 编写一个“Spring风格”的Flink任务

依赖搞定后,我们来写业务代码。目标是实现一个经典场景:从Kafka读取设备上报的数据,如果某个设备超过一定时间没上报,就判定它离线,并把状态更新到MySQL。我们会充分利用Spring的注解来让代码更清晰。

首先,是SpringBoot的启动类,没什么特别的,就是标准的@SpringBootApplication。

@SpringBootApplication
public class FlinkWithSpringApplication {
    public static void main(String[] args) {
        SpringApplication.run(FlinkWithSpringApplication.class, args);
    }
}

接下来是核心,我们创建一个被Spring管理的Bean来定义Flink作业。这里用@Component注解,并且通过@ConditionalOnProperty加了个开关,方便在测试环境灵活启停任务。

@Component
@ConditionalOnProperty(name = "flink.job.device-status.enabled", havingValue = "true")
public class DeviceStatusMonitoringJob {

    @Value("${spring.kafka.bootstrap-servers}")
    private String kafkaBootstrapServers;
    @Value("${flink.job.device-status.topic}")
    private String sourceTopic;

    @Autowired
    private DeviceStatusCalculator statusCalculator;
    @Autowired
    private DeviceStatusSink deviceStatusSink;

    @PostConstruct
    public void startFlinkJob() throws Exception {
        // 1. 获取执行环境
        final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        // 设置并行度为1,方便调试,生产环境根据资源调整
        env.setParallelism(1);
        // 开启Checkpoint,每5秒一次,这是保证状态一致性的关键
        env.enableCheckpointing(5000);

        // 2. 配置Kafka Source
        Properties kafkaProps = new Properties();
        kafkaProps.setProperty("bootstrap.servers", kafkaBootstrapServers);
        kafkaProps.setProperty("group.id", "device-status-monitor");
        // 如果Kafka有认证,在这里配置
        // kafkaProps.setProperty("security.protocol", "SASL_PLAINTEXT");

        FlinkKafkaConsumer<String> consumer = new FlinkKafkaConsumer<>(
                sourceTopic,
                new SimpleStringSchema(),
                kafkaProps
        );
        // 从最新位置开始消费
        consumer.setStartFromLatest();

        // 3. 构建数据处理流水线
        DataStream<String> stream = env.addSource(consumer);
        // 打印原始数据,用于调试
        stream.print("原始数据");

        // 使用注入的Bean进行计算和输出
        DataStream<String> offlineDevices = stream
                .keyBy(data -> JSON.parseObject(data, DeviceData.class).getDeviceId())
                .process(statusCalculator);

        offlineDevices.addSink(deviceStatusSink);

        // 4. 异步执行,避免阻塞SpringBoot主线程
        new Thread(() -> {
            try {
                env.execute("Device Status Monitoring Job");
            } catch (Exception e) {
                // 这里一定要做好异常处理,比如发送告警
                e.printStackTrace();
            }
        }).start();
        System.out.println("Flink作业已提交...");
    }
}

这段代码有几个关键点:

  1. StreamExecutionEnvironment.getExecutionEnvironment():这个方法很聪明,在本地运行时会创建一个本地环境,而当你把作业提交到集群时,它会自动识别集群环境。这为我们实现“一套代码,两种运行方式”打下了基础。
  2. @PostConstruct:这个注解让startFlinkJob方法在Bean初始化完成后自动执行,相当于作业自动启动。
  3. 异步线程启动:Flink的env.execute()是阻塞的。如果直接在@PostConstruct里调用,SpringBoot应用启动后就会卡住,Web容器也无法提供服务。所以必须开一个新线程来跑。
  4. 依赖注入:我们把核心的业务逻辑(statusCalculator)和数据输出(deviceStatusSink)都做成了Spring Bean,在这里直接注入使用,代码结构非常清晰。

2.3 实现业务逻辑与数据输出

业务计算逻辑我们放在一个继承了Flink KeyedProcessFunction的类里,它同样是一个Spring Bean。这样,我们就能在Flink的算子内部使用Spring管理的服务了,比如查询数据库获取设备离线阈值。

@Component
public class DeviceStatusCalculator extends KeyedProcessFunction<String, DeviceData, String> {

    // 使用ValueState来为每个设备维护最后一次上报时间
    private ValueState<Long> lastUpdateTimeState;
    @Autowired
    private DeviceConfigService configService; // 假设这是一个能查设备配置的Spring Service

    @Override
    public void open(Configuration parameters) {
        ValueStateDescriptor<Long> descriptor = new ValueStateDescriptor<>(
                "lastUpdateTime",
                Long.class
        );
        lastUpdateTimeState = getRuntimeContext().getState(descriptor);
    }

    @Override
    public void processElement(DeviceData value, Context ctx, Collector<String> out) throws Exception {
        Long lastTime = lastUpdateTimeState.value();
        long currentTime = ctx.timestamp();

        // 更新状态
        lastUpdateTimeState.update(currentTime);

        // 获取该设备的离线判定间隔(毫秒),这个配置可能来自数据库
        long offlineThreshold = configService.getOfflineThreshold(value.getDeviceId());
        // 注册一个定时器,在`当前时间 + 阈值`时触发
        long timerTime = currentTime + offlineThreshold;
        ctx.timerService().registerProcessingTimeTimer(timerTime);
    }

    @Override
    public void onTimer(long timestamp, OnTimerContext ctx, Collector<String> out) throws Exception {
        // 定时器触发时,检查状态
        Long lastSavedTime = lastUpdateTimeState.value();
        // 如果最后一次更新时间 + 阈值 正好等于这个触发时间,说明期间没有新数据
        if (lastSavedTime != null && (lastSavedTime + configService.getOfflineThreshold(ctx.getCurrentKey())) == timestamp) {
            out.collect(ctx.getCurrentKey()); // 输出离线设备ID
        }
        // 清理状态,避免状态无限增长
        lastUpdateTimeState.clear();
    }
}

数据输出到MySQL的Sink,我们也做成一个Spring Bean,继承自Flink的RichSinkFunction。在open方法里,我们可以用Spring注入的DataSource来获取连接,而不是自己写一堆JDBC样板代码。

@Component
public class DeviceStatusSink extends RichSinkFunction<String> {

    @Autowired
    private DataSource dataSource; // Spring Boot自动配置的数据源
    private Connection connection;

    @Override
    public void open(Configuration parameters) throws Exception {
        super.open(parameters);
        // 从Spring管理的连接池获取连接
        connection = dataSource.getConnection();
    }

    @Override
    public void invoke(String deviceId, Context context) throws Exception {
        String sql = "UPDATE device SET status = 'OFFLINE', update_time = NOW() WHERE id = ?";
        try (PreparedStatement ps = connection.prepareStatement(sql)) {
            ps.setString(1, deviceId);
            ps.executeUpdate();
        }
    }

    @Override
    public void close() throws Exception {
        if (connection != null && !connection.isClosed()) {
            connection.close();
        }
        super.close();
    }
}

2.4 配置文件与本地运行

最后,在application.yml里把配置补全。这里我们把Flink作业的开关、Kafka主题等都放在配置文件里,灵活性很高。

server:
  port: 8080

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/your_db?useSSL=false&serverTimezone=UTC
    username: root
    password: your_password
    driver-class-name: com.mysql.cj.jdbc.Driver
  kafka:
    bootstrap-servers: localhost:9092

# 自定义Flink作业配置
flink:
  job:
    device-status:
      enabled: true # 作业总开关
      topic: device-data-topic # Kafka源主题

现在,你可以直接运行FlinkWithSpringApplication的main方法了。如果一切顺利,你会看到SpringBoot启动日志,然后Flink作业提交,开始消费Kafka数据并在控制台打印。在本地IDE里,这就是一个标准的SpringBoot应用,调试、打断点都非常方便。这就是我们想要的第一步:在熟悉的SpringBoot环境下,像开发Web服务一样开发流处理任务。

3. 打包的艺术:一个JAR包,两种运行方式

代码写好了,本地也跑通了,接下来就要考虑部署了。这里是我们遇到的第一个“深水区”:打包。我们的目标很明确,打出来的一个JAR包,要既能用java -jar在本地或单机运行,又能通过flink run命令提交到标准的Flink集群(比如YARN或K8s上的Session/Application集群)。这要求我们对SpringBoot和Flink的打包机制有深入的理解。

3.1 为什么不能用默认的spring-boot-maven-plugin?

SpringBoot的官方打包插件spring-boot-maven-plugin非常好用,它会生成一个“胖JAR”(Fat Jar),里面包含了所有依赖和一个特殊的类加载器,使得java -jar就能运行。但是,这个胖JAR的结构对于Flink集群来说是不兼容的。Flink集群在分发用户JAR包到各个TaskManager节点时,期望的是一个标准的、符合其类加载约定的JAR包。SpringBoot的胖JAR会把所有类放在BOOT-INF/classes下,依赖放在BOOT-INF/lib下,Flink的类加载器无法正确识别这个结构,会导致ClassNotFoundException。

3.2 使用maven-shade-plugin打造“兼容JAR”

经过多次实践,maven-shade-plugin是目前最可靠的解决方案。它的作用是将项目依赖的JAR包解压,然后和你的项目代码重新打包成一个新的、扁平的JAR(Uber Jar)。同时,它还能处理一些资源文件的合并,比如META-INF/services下的SPI文件。

下面是一个经过大量踩坑后总结出来的、可用的pom.xml中build配置:

<build>
    <finalName>flink-springboot-job</finalName>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-shade-plugin</artifactId>
            <version>3.3.0</version>
            <executions>
                <execution>
                    <phase>package</phase>
                    <goals>
                        <goal>shade</goal>
                    </goals>
                    <configuration>
                        <createDependencyReducedPom>false</createDependencyReducedPom>
                        <!-- 排除一些可能引起冲突的依赖 -->
                        <artifactSet>
                            <excludes>
                                <!-- 排除Flink自带的slf4j-log4j12,避免日志冲突 -->
                                <exclude>org.slf4j:slf4j-log4j12</exclude>
                                <!-- 排除Flink自带的log4j,使用集群提供的 -->
                                <exclude>log4j:log4j</exclude>
                            </excludes>
                        </artifactSet>
                        <filters>
                            <filter>
                                <artifact>*:*</artifact>
                                <excludes>
                                    <!-- 排除模块描述文件,避免Java 9+模块化问题 -->
                                    <exclude>module-info.class</exclude>
                                    <!-- 排除签名文件,避免安全校验失败 -->
                                    <exclude>META-INF/*.SF</exclude>
                                    <exclude>META-INF/*.DSA</exclude>
                                    <exclude>META-INF/*.RSA</exclude>
                                </excludes>
                            </filter>
                        </filters>
                        <!-- 关键!合并Spring的配置文件 -->
                        <transformers>
                            <!-- 合并spring.handlers和spring.schemas,Spring XML配置需要 -->
                            <transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
                                <resource>META-INF/spring.handlers</resource>
                            </transformer>
                            <transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
                                <resource>META-INF/spring.schemas</resource>
                            </transformer>
                            <!-- 合并Spring Boot的spring.factories,用于自动配置 -->
                            <transformer implementation="org.springframework.boot.maven.PropertiesMergingResourceTransformer">
                                <resource>META-INF/spring.factories</resource>
                            </transformer>
                            <!-- 合并其他服务的配置文件,如ServiceLoader机制使用的 -->
                            <transformer implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer"/>
                            <!-- 指定主类 -->
                            <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                <mainClass>com.yourcompany.flink.FlinkWithSpringApplication</mainClass>
                            </transformer>
                        </transformers>
                    </configuration>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

这个配置有几个灵魂之处:

  1. 排除冲突依赖:排除了Flink集群环境已经提供的日志实现(log4j和slf4j绑定器),避免“一个类被多个加载器加载”的冲突。
  2. 合并Spring配置文件:Spring框架和Spring Boot在启动时需要读取META-INF/下的特定文件来发现配置。多个依赖JAR里都有这些文件,必须用AppendingTransformer把它们的内容合并起来,否则Spring容器可能无法正确初始化。
  3. 指定主类:ManifestResourceTransformer确保了生成的JAR包的MANIFEST.MF文件里有正确的Main-Class,这样java -jar才能找到入口。

3.3 本地运行与集群提交的切换技巧

打包完成后,你会得到一个target/flink-springboot-job.jar。现在,这个JAR包已经具备了双重身份。

本地运行(测试/开发): 直接在命令行执行:

java -jar target/flink-springboot-job.jar

SpringBoot会启动,Flink作业也会在同一个JVM内以本地模式运行。所有日志都会输出到控制台,非常适合调试。

提交到Flink集群(生产): 假设你有一个在运行的Flink Standalone集群或YARN Session,使用flink run命令提交:

./bin/flink run -c com.yourcompany.flink.FlinkWithSpringApplication \
    -p 4 \ # 设置并行度
    target/flink-springboot-job.jar

这里-c参数指定了主类。Flink集群的JobManager会加载这个JAR,启动一个新的JVM来运行我们指定的主类。这时,Spring容器会在TaskManager的JVM里启动,并开始执行Flink作业。

一个实用的配置技巧:为了让同一个JAR包能适应两种环境,我们可以在application.yml里使用Spring的Profile功能。例如,为本地运行专门写一个application-local.yml,里面配置本地Kafka和MySQL地址;为集群环境写一个application-prod.yml,里面配置生产环境的地址。然后通过启动参数--spring.profiles.active=prod来激活对应的配置。在Flink run命令里,可以这样传递参数:

./bin/flink run -c com.yourcompany.flink.FlinkWithSpringApplication \
    target/flink-springboot-job.jar \
    --spring.profiles.active=prod

4. 提交到Flink集群:从Standalone到云原生

打包问题解决后,我们就可以把任务部署到真正的集群环境了。不同的集群模式(Standalone, YARN, Kubernetes)在提交方式、资源管理和高可用上略有不同,但核心思想是一致的:我们的JAR包是一个“黑盒”,Flink集群负责调度和执行它。

4.1 提交到Standalone集群

Standalone集群是Flink自带的简易集群模式,适合小规模部署和测试。提交命令上面已经展示了。这里再补充几个常用的参数:

./bin/flink run \
    -m yarn-cluster \ # 如果提交到YARN,则用这个指定ResourceManager地址
    -c com.yourcompany.flink.FlinkWithSpringApplication \
    -p 4 \ # 作业并行度,决定了TaskManager上任务槽(slot)的使用数量
    -ys 2 \ # 每个TaskManager的slot数量(YARN模式)
    -yjm 1024m \ # JobManager内存(YARN模式)
    -ytm 2048m \ # TaskManager内存(YARN模式)
    -d \ # 以分离模式运行,提交后命令行立即返回
    /path/to/your/flink-springboot-job.jar \
    --spring.profiles.active=prod \
    --flink.job.device-status.topic=prod-device-data

重点观察提交后的行为:在Flink的Web UI上,你可以看到作业的运行状态、各个算子的吞吐量、背压情况等。我们的SpringBoot应用实际上是在JobManager启动时被初始化的,然后作业图被分发到各个TaskManager。每个TaskManager的JVM里都会有一个独立的Spring ApplicationContext实例。这意味着,如果你在Sink里用了@Autowired注入的DataSource,那么每个并行子任务实例都会有一个独立的数据库连接池。这既是好处(连接隔离),也需要注意(连接数可能会膨胀)。

4.2 在YARN和Kubernetes上运行

对于生产环境,YARN(如果已有Hadoop集群)和Kubernetes是更主流的选择。

YARN Per-Job模式:这是最常用的方式。每个Flink作业作为一个独立的YARN Application启动,拥有自己专属的JobManager和TaskManager。资源隔离性好,但启动稍慢。提交命令和上面类似,需要正确配置Hadoop的配置文件路径。

Kubernetes Native Application:这是未来的趋势。你可以为Flink作业定义一个Kubernetes Deployment和Service。Flink提供了专门的Kubernetes集成,可以通过kubectl或Helm Chart来部署。在这种模式下,我们的SpringBoot JAR包通常被打包进Docker镜像中。镜像的Dockerfile基础层需要包含Flink的发行版和Java运行时,然后将我们的JAR包复制到/opt/flink/usrlib/目录下,Flink在启动Pod时会自动加载。这种方式实现了极致的容器化和弹性伸缩。

4.3 集群运行时的常见问题与调优

把SpringBoot应用扔到集群后,可能会遇到一些本地没有的问题:

  1. 类加载器冲突:这是最常见的问题。表现是ClassNotFoundException, NoSuchMethodError, 或者LinkageError。根本原因是Flink有自己的用户代码类加载器(User Code ClassLoader),而Spring也有复杂的类加载逻辑。我们之前的打包配置(排除冲突JAR、合并资源)就是为了解决这个问题。如果还遇到,可以尝试在flink-conf.yaml中调整类加载策略,比如设置classloader.resolve-order: parent-first(优先从父加载器加载,即Flink的核心依赖),或者更激进地设置classloader.check-leaked-classloader: false来绕过某些类加载器泄漏检查(需谨慎)。

  2. 日志配置:在集群上,我们通常希望日志输出到文件,并由日志收集系统(如ELK)抓取。由于我们排除了Logback,所以需要为Flink提供Log4j的配置文件。可以将一个log4j.properties文件放在JAR包的根目录,或者通过Flink的-Dlog.file参数指定。在配置文件里,可以配置输出到文件,并按日期或大小滚动。

  3. 内存与GC调优:SpringBoot应用本身有一定内存开销,加上Flink的状态管理,需要给TaskManager分配足够的内存。除了通过-ytm设置总内存,更精细的调优是在flink-conf.yaml里设置taskmanager.memory.process.size和taskmanager.memory.jvm-overhead。对于有大量状态的作业,可能需要增加JVM堆外内存(taskmanager.memory.managed.fraction)。GC方面,如果作业延迟敏感,可以考虑使用G1垃圾回收器,并在JVM参数中添加相应的调优选项。

  4. 检查点(Checkpoint)与状态后端:我们代码里用env.enableCheckpointing(5000)开启了检查点。在生产环境,一定要配置一个可靠的状态后端(State Backend),比如RocksDB(增量检查点,适合大状态)或FsStateBackend(内存+文件,适合小状态)。这通常通过env.setStateBackend(...)在代码中设置,或者在flink-conf.yaml中全局配置。检查点是保证Flink作业故障恢复时状态一致性的基石,务必重视。

5. 进阶:生产级监控、调试与最佳实践

任务在集群上稳定运行后,我们还需要考虑如何监控它的健康状态,出了问题如何快速定位,以及如何让整个架构更健壮。

5.1 监控指标集成

Flink提供了丰富的Metric系统,可以暴露作业的吞吐量、延迟、水位线、检查点时长、背压状态等。我们可以通过以下方式集成到现有的监控体系:

  • 推送到Prometheus:这是最流行的方案。在flink-conf.yaml中配置metrics.reporter.prom.class: org.apache.flink.metrics.prometheus.PrometheusReporter,并指定端口。Prometheus会定期拉取指标,然后在Grafana中制作精美的监控大盘。
  • 与SpringBoot Actuator集成:我们的应用本身是SpringBoot的,可以引入spring-boot-starter-actuator依赖,暴露/actuator/metrics端点。我们可以写一个自定义的FlinkMetricsReporter,将Flink的关键指标注册到Spring的MeterRegistry中,这样就能通过统一的Actuator端点查看,并方便地对接Micrometer支持的各种监控后端(如Prometheus, InfluxDB)。
  • 业务指标自定义:除了系统指标,业务指标也很重要。比如在DeviceStatusCalculator里,我们可以通过getRuntimeContext().getMetricGroup().counter("offlineDevicesCount")定义一个计数器,每发现一个离线设备就加一。这个自定义指标也会被上面的报告器收集。

5.2 高效的调试与日志排查

在分布式环境下调试比本地复杂得多。我总结了几条实用经验:

  • 善用Flink Web UI:这是第一现场。通过UI可以直观看到数据流图、每个算子的输入输出速率、背压情况。如果某个算子卡住了,背压指标会飙升,能快速定位瓶颈。
  • 集中化日志收集:确保所有TaskManager和JobManager的日志都被收集到像ELK或Splunk这样的中心化系统。在日志中为每条记录关联上Flink的jobId, taskId, subtaskIndex等信息,对排查数据乱序、数据丢失问题非常有帮助。可以在Flink的log4j.properties里配置日志格式,加入这些上下文信息。
  • 远程调试(谨慎使用):在测试环境,如果问题难以复现,可以开启JVM远程调试。在提交作业时,为TaskManager和JobManager添加JVM参数-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005。然后从IDE连接到对应的主机和端口。注意,这会影响性能,且生产环境绝对不要开启。
  • 保存点(Savepoint)与状态迁移:这是Flink的“大杀器”。在升级作业代码(比如修复Bug或增加新功能)时,可以先从当前运行作业触发一个保存点(flink savepoint <jobId>),它会把所有算子的状态快照持久化到文件系统(如HDFS)。然后用新代码的JAR包,从这个保存点恢复启动(flink run -s <savepointPath> ...)。这样状态可以无缝迁移,实现“零停机”升级。我们SpringBoot应用中的ValueState等状态都会被完美保存和恢复。

5.3 架构设计与最佳实践

最后,分享几个我在实际项目中总结出的、与SpringBoot集成相关的架构心得:

  • 轻量化的Spring Context:在Flink的每个TaskManager里都启动一个完整的Spring容器是有开销的。务必保持Spring Context的轻量化。避免使用@ComponentScan扫描过大的包范围,尽量明确指定扫描路径。对于非必须的自动配置(如Spring MVC、Tomcat),可以用@SpringBootApplication(exclude = {...})排除掉。
  • 外部化配置与敏感信息管理:数据库密码、Kafka认证信息等绝不能硬编码在application.yml里。推荐使用配置中心,如Spring Cloud Config、Apollo或Nacos。我们的Flink作业启动时,可以从配置中心拉取最新配置。对于云原生环境,也可以使用Kubernetes Secrets。
  • 考虑使用Flink CDC替代自定义Source:如果你的数据源是MySQL、PostgreSQL等数据库,并需要实时捕获变更,强烈建议使用Flink CDC(Change Data Capture)连接器,而不是自己写代码轮询或解析binlog。Flink CDC能精准捕获增删改事件,并天然集成到Flink的流处理体系中,比“SpringBoot + 定时任务”的方案更优雅、更强大。
  • 作业生命周期管理:我们目前是通过@PostConstruct在应用启动时自动提交作业。在生产中,你可能需要更灵活的控制,比如通过REST API来动态启停作业。这可以通过在SpringBoot中暴露一个Controller,在Controller里获取StreamExecutionEnvironment Bean并调用execute或cancel方法来实现。不过要注意线程安全和环境隔离。

这条路我走过,坑也踩过不少。从最初的手忙脚乱,到现在的驾轻就熟,最大的感受是:技术组合没有银弹,SpringBoot和Flink的集成确实会带来一些复杂性,但它带来的开发效率提升和现有资产复用价值,在很多业务场景下是值得的。希望这篇长文能帮你扫清障碍,顺利地把你的流处理业务推向云端。

springboot集成flink并发布flink集群端运行 背景:近期项目需要,引入flink,研究了下flink,步步踩坑终于可以单独运行,也可发布到集群运行,记录下踩坑点。开发环境:idea+springboot(2.3.5.RELEASSE)+kafka(2.8.1)+mysql(8.0.26)。废话不多说,直接上可执行代码。 以下代码实现了某个时间间隔,设备不上传数据,判断为离线的逻辑 一、项目application创建 /** * flink任务提交application * * @author wangfenglei */ @Spring 阅读详情

相关推荐

【Flink】SpringBoot整合Flink并以集群方式运行,可以通过接口来动态创建执行任务,并行度可通过接口动态配置,可以和业务进行交互,灵活性极强,扩展性极高

【Flink】SpringBoot整合Flink并以集群方式运行,可以通过接口来动态创建执行任务,并行度可通过接口动态配置,可以和业务进行交互,灵活性极强,扩展性极高

weixin_65690086的博客 8890

基于SpringBoot+Flink构建千万级订单生成架构设计和实现

基于SpringBoot+Sharding-JDBC+Flink构建千万级订单生成架构设计和落地实现随着互联网发展,数据不断增加,像订单数据达到千万级别该怎么存储,怎么生成呢?随着数据量的增长,一般DB的架构,经历如下演进:单库主从、单库双主多从架构、分区表、横向分表、多库。分库分表实现会带来怎么的困难?如何监控和分析订单分布等?本课程将以实战方式讲解各个架构,让大家再实战中掌握各个知识点,同时也会实战讲解分表分库监控分析,掌握SpringBoot知识的同时也掌握大数据的相关技术。 课程所用的开发环境为:Window10 开发工具:IDEA本课程用到技术:SpringBootSharding-JDBCFlinkMysqlBinlogCanalKafkaMaven等

Flink入门系列--和Springboot框架结合(1.14.3版本)

本文 Flink 版本为 1.14.3。 本文主要讲解如何将 Flink 和 Springboot 两大框架融合在一起, 可以对接 SpringCloud 生态系统,比如分布式配置中心、服务注册和发现、负载均衡等; 可以通过 Restful 接口的形式提交 Flink 任务。 本地工程构建 软件环境: Flink 1.14.3 Springboot 2.0.3.RELEASE JDK 11 <?xml version="1.0" encoding="UTF-8"?> <proj.

打酱油的葫芦娃 1万+

在SpringBoot启动后 在Application类直接调用Bean类之中的方法

目录 1、应用场景直击 2、代码实现 2.1、使用static方式获得Bean实例 2.2、在Application之中直接获得配置信息 3、总结 4、参考文章 1、应用场景直击 最近因为公司变化;要求把以前在百度云上的音视频文件和文档迁移到阿里云环境下。因为本人被分派了此任务要求把百度云账号(2个)、其中一个账号直接下载文件;另外一个账号需要按照系统下载文件。于是...

一颗浑身披带雪花的松树---[雪松] 5189

利用Python实现纬度加权平均(即NCL中的wgt_areaave)

当处理全球数据的时候,最常见的分析就是全球、北半球平均了,这时候一定要注意要根据纬度等信息进行加权,求加权平均,要不然结果肯定会不准。但是对于Python中,常规的计算包里面是没有的,或许现在有其他包可以实现,也可以告诉我~。

记录基于python语言处理气象问题的一些代码,包括不限于气象数据读取、机器学习和深度学习建模。 5745

从零到一:RT-Thread与W5500的硬件抽象层设计哲学与实践启示

本文深入探讨了RT-Thread操作系统下W5500以太网模块的硬件抽象层(HAL)设计哲学与实践。通过GD32F103和STM32F103平台的适配案例,详细阐述了如何利用RT-Thread的驱动框架实现跨平台硬件无关性、模块化设计及配置定制,为嵌入式开发者提供了可复用的HAL设计方法论和实战经验。

7z8x2c4v6b9的博客 199

智能商超实战指南:从架构设计到落地部署的全流程解析

参考校园购物类系统的成熟做法,后台服务建议采用SpringBoot + MyBatisPlus + MySQL的组合,用户端采用UniApp以一套代码编译为小程序、H5及App,管理后台则基于Vue + ElementUI搭建。对于技术团队而言,从零搭建一套可落地的智能商超方案,核心在于厘清端、边、云协同的架构层次,并基于成熟的开源技术栈快速迭代。智能商超的业务域可拆分为会员中心、商品中心、订单中心、库存中心、配送中心和IoT设备管理六大模块,与同城生鲜配送系统的架构思路一。智能商超的终价值在于数据闭环。

m0_73514975的博客 199

Xilinx Chip2Chip IP核实战:Aurora PHY通信配置与仿真避坑指南

本文深入解析Xilinx Chip2Chip IP核与Aurora PHY的通信配置与仿真优化,提供实战避坑指南。通过AXI协议转换桥实现FPGA间高速数据传输,详细讲解Aurora PHY参数设置、仿真加速技巧及常见问题解决方案,帮助工程师快速部署稳定高效的芯片间通信系统。

g5h6i7j的博客 1007

Springboot+Vue智慧养老手表管理系统:家长与养老院管理员操作平台,涵盖个人、家庭、...

后台门户则面向运营商、社区医生、家属三类角色,提供设备管理、数据可视化、报警闭环、电子围栏、用药提醒、远程固件升级等完整功能。智慧养老手表管理系统通过“SSM + Vue”的经典组合,配合 MQTT、InfluxDB、Redis、Flink 等开源组件,构建了一套高可用、可扩展、安全合规的 IoT 后台门户。模板使用 FreeMarker 渲染,支持多语言、夜间静默期。功能有:个人管理,公告管理,家庭管理,加好友管理,老人健康管理,基础管理,加好友板等框架:springboot、mybatis、vue。

2500_94306685的博客 1460

基于51单片机的贪吃蛇游戏设计

本科时候做的一个课程作业,自己打一个很简易的电路,比较有意思且易上手,故将之记录下来。(全套的仿真及代码,演示视频,课程报告以及PPT展示上传在优快云下载区) 一. 实验目的 (1) 通过对C51语言的理解,编写程序实现对贪吃蛇的有效控制; (2) 通过对51单片机硬件的学习,学会运用面包板,独立按键、点阵屏等,完成对完整电路的搭建过程; (3) 通过对Proteus仿真软件的学习,实现基于STC89C52单片机的8*8点阵贪吃蛇的硬件电路仿真。 二. 实验介绍 贪吃蛇是一款经典小游戏,其游戏的规则是:玩

山山の十三先生 2万+

【LDPC-7】LLR量化位宽对LDPC译码性能的影响分析——以最小和译码算法为例进行matlab仿真

最小和译码算法的步骤如下:最后译码结果如果满足或者完成所有迭代次数,则译码算法停止迭代,否则继续进行译码迭代操作。

FPGA/MATLAB学习教程/源码/项目合作开发 1472

springboot+vue智慧养老手表管理系统 本系统共分为两个角色:家长,养老院管理员 功...

后台门户则面向运营商、社区医生、家属三类角色,提供设备管理、数据可视化、报警闭环、电子围栏、用药提醒、远程固件升级等完整功能。智慧养老手表管理系统通过“SSM + Vue”的经典组合,配合 MQTT、InfluxDB、Redis、Flink 等开源组件,构建了一套高可用、可扩展、安全合规的 IoT 后台门户。模板使用 FreeMarker 渲染,支持多语言、夜间静默期。功能有:个人管理,公告管理,家庭管理,加好友管理,老人健康管理,基础管理,加好友板等框架:springboot、mybatis、vue。

QQ27699885的博客 864

STM32入门教程:智能汽车控制

智能汽车是近年来快速发展的领域之一,它结合了嵌入式系统、传感器和通信技术,通过智能化的控制算法和决策系统实现自主导航、避障、环境感知等功能。在这篇教程中,我们将以 STM32 微控制器为核心,通过编写代码案例来介绍智能汽车的控制原理和实现方法。步骤三:决策与执行 最后,我们根据传感器数据做出相应的决策,并执行相应的动作。案例:智能汽车的避障功能 在这个案例中,我们将实现智能汽车的避障功能。感知系统负责感知汽车周围的环境,包括障碍物的距离、车辆的角度等信息。下面我们通过一个具体的案例来演示代码的编写。

2401_85258012的博客 929

springboot智慧健康保障平台 开题报告

HDFS放宽了POSIX的要求,可以以流的形式访问文件系统中的数据。2、同时增加文字触发提醒,设置提醒语,有相同字段的数据,会触发弹框提醒,例如设置状态提醒:特急/加急/一般 增加自定义提醒语(如:库存不足,请补货)8、AI续写、AI优化、AI校对、AI翻译:新增AI接口,编辑器接入AI,可以实现AI续写、AI优化、AI校对、AI翻译,可以帮你实现自动化,ai帮你完成文档。对于本系统,我们提供全方位的支持,包括修改时间和标题,以及完整的安装、部署、运行和调试服务,确保系统能在你的电脑上顺利运行。

bishe288的博客 317

使用 MATLAB/Simulink 对基于同步发电机的双机系统进行建模

双机系统(Two-Machine System)是电力系统中用于研究动态稳定性和控制策略的一个典型模型。它由两台同步发电机通过输电网络相互连接,模拟实际电网中的互联操作。当发生短路故障时,系统的暂态稳定性会受到挑战,可能导致发电机失步或电压崩溃。本教程将带你使用 MATLAB/Simulink 对基于同步发电机的双机系统进行建模,并对其在短路故障条件下的暂态稳定性进行仿真和分析。

amy_mhd的博客 219

Open Dynamics Engine(ODE)物理引擎教程(1)--下载与安装准备

引言 ODE是一个免费的工业级库,用于模拟关节式刚体动力学,例如地面车辆、腿部生物和虚拟现实环境中的移动对象。它具有快速、灵活、健壮和独立于平台的特点,具有先进的关节、摩擦接触和内置的碰撞检测功能。 项目主页:http://www.ode.org/ 线上手册:http://ode.org/wiki/index.php?title=Manual 本教程为博主亲自亲测过程的总结,转载请注明出处! ...

腿足机器人领域 2219

基于Spring Boot与Vue的全栈物联网平台架构实践:如何实现企业级物联网应用快速搭建

FastBee开源物联网平台为中小企业和开发者提供了一个完整的物联网解决方案,通过Spring Boot后端与Vue前端的全栈架构设计,实现了设备管理、数据监控、多端应用的一体化支持。该项目采用模块化设计理念,内置MQTT服务端,无需额外部署第三方消息中间件,简化了物联网应用的开发与部署流程。 ## 项目价值定位:商业可行性与技术实用性的平衡 FastBee的核心理念是降低物联网应用的技术门槛

gitblog_00579的博客 1025

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过,这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后,重新检测通过。

AI编程实战:从LLM到智能体的工程化应用

大语言模型(LLM)作为AI编程的核心组件,通过概率计算实现代码生成,其自回归特性带来局部最优和上下文稀释等工程挑战。智能体(Agent)技术通过反射层、规划层和执行层的三级架构,显著提升任务成功率。在RAG(检索增强生成)系统中,分块策略和向量化模型的选择直接影响召回效果,而记忆系统的分层设计能有效管理对话历史与知识库连接。这些技术在代码补全、自动化测试等开发场景中展现价值,结合Cursor、Claude等工具链可进一步提升开发效率。AI与CI/CD的融合更实现了构建优化、故障自愈等运维突破,为软件工程带

weixin_30673611的博客 352

怀旧版电脑GBC模拟器

再现原版GBC掌机的界面,电脑运行连游戏界面都一样大小,很怀旧,很真实,(英文版)强烈推荐,很小的文件,很难才找到的。

efm32 入门.pdf

本PDF共计22页,介绍的是操作驱动API,下载与否自己斟酌。

程序员转型大模型的黄金机遇与核心挑战

大模型技术正在重塑科技行业格局,为程序员提供了前所未有的转型机遇。理解大模型技术栈的全景是成功转型的关键,包括基础设施层、核心算法层、工具链层和应用层。程序员的核心可迁移技能,如系统设计能力、代码工程化能力和性能优化经验,在大模型领域具有独特价值。通过技术栈复用,程序员可以快速进入大模型工程类岗位,如平台工程、应用集成和模型部署方向。本文深入分析了程序员转型大模型的四大方向,并提供了实战案例和避坑指南,帮助程序员把握这一黄金机遇。

diandingyin9417的博客 580

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

springcloud(一): 大话Spring Cloud

研究了一段时间spring boot了准备向spirng cloud进发,公司架构和项目也全面拥抱了Spring Cloud。在使用了一段时间后发现Spring Cloud从技术架构上降低了对大型系统构建的要求,使我们以非常低的成本(技术或者硬件)搭建一套高效、分布式、容错的平台,但Spring Cloud也不是没有缺点,小型独立的项目不适合使用,另外对分布式事物的支持暂时也没有。Spring C...

justlpf的专栏 480

开源 | 慧知开源OCPP1.6J欧标充电桩管理平台 V1.8.8

⚡️慧知开源充电桩平台全套源码⚡️;⚡️OCPP1.6J 充电桩管理系统⚡️;⚡️跨境充电小程序⚡️;⚡️充电桩 SaaS 运营平台⚡️;,SpringCloud+MySQL+Redis+Nacos+Uniapp+Netty+MQTT,多租户隔离、OCPP1.6J 全协议、全球多支付通道、高并发设备接入、车主端多端应用、运营管理后台、充电桩模拟器、一站式跨境充电数字化运营解决方案

李文慧 中国开源充电桩平台第一人;李文慧 国内知名开源工作者 全栈工程师 华为云最具价值专家 1305

SpringBoot集成flink

flink

usa_washington的博客 7824

Spring Boot 整合 Apache Flink 教程

通过以上步骤,即可实现Spring Boot与Apache Flink的深度整合。这种架构特别适合需要将实时流处理能力嵌入微服务体系的场景,如实时风控系统、IoT数据处理平台等。Apache Flink 是一个高性能的分布式流处理框架,而Spring Boot提供了快速构建企业级应用的能力。:通过Micrometer接入Spring Boot Actuator。:集成Flink State Backend(如RocksDB):将打包后的jar提交到Flink集群。

qq479850581的博客 3396

springboot-集成flink最佳实践和打包部署

spring-boot集成flink

ssehs的博客 6952

SpringBoot整合Flink,实现一个用户个性化推荐系统

通过SpringBoot结合Flink的高性能流处理能力,开发者可以构建出高效、可靠的实时数据处理解决方案。这些应用不仅能够提高企业的运营效率,还能增强竞争力。应用场景1. 推荐系统:根据用户的实时行为生成个性化推荐。更新用户画像,以适应不断变化的兴趣和偏好。2. 事件驱动架构:在微服务架构中处理跨服务的消息传递,确保系统的低延迟和高吞吐量。处理来自不同来源的事件,并根据业务规则执行相应的操作。3...

qq_18244417的博客 1396

SpringBoot整合Kafka、Flink实现流式处理

SpringBoot整合Kafka、Flink实现流式处理

weixin_46619605的博客 3669
上一篇: 中国毫米波雷达产业分析4——康养雷达市场趋势与智能家居融合(四、五、六)
下一篇: SpringBoot+MyBatis多数据源实战:跨库数据同步方案解析
python9snake
博客等级 码龄1天 0粉丝 1724原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值