Skip to main content

Overview

Building Apache Flink applications should feel as clean, safe, and productive as writing modern Spring Boot backend services. Once you experience declarative bootstrapping, fail-fast configuration, and zero-Kryo guarantees, you will never write manual Flink boilerplate again.

1. Type-safe configuration DTOs​

Flinkboot ships with pre-built, production-tested DTOs for the execution environment (JobProperties) and official connectors (KafkaSourceProperties, FlussSourceProperties). Simply assemble them with your own domain records or POJOs with full Jakarta Bean Validation (@NotNull, @Valid), with no manual Jackson parsing required.

// Composed application configuration record
public record AppConfig(
    // Built-in Flinkboot DTO: covers RocksDB, restart strategies, metrics, checkpoints
    @Valid @NotNull @JsonProperty("job") JobProperties job,

    // Built-in Flinkboot DTO: covers brokers, topics, offset strategies, vendor escape-hatch
    @Valid @NotNull @JsonProperty("kafka-source") KafkaSourceProperties kafkaSource,

    // Your custom business domain settings (records or POJOs with Bean Validation)
    @Valid @NotNull @JsonProperty("alerting") AlertingProperties alerting
) {}

2. Declarative YAML schema​

Your configuration files map 1:1 to your type-safe DTOs. Instead of scattering parameters across ad-hoc CLI arguments, Java System Properties, and flat properties files, Flinkboot organizes everything into a hierarchical YAML contract supporting profile activation, parameter placeholders, and environment variable substitution.

# application.yaml - Maps 1:1 to your AppConfig DTO
job:
  name: "order-fraud-detector"
  parallelism: 8
  checkpointing:
    interval: 60000
    timeout: 120000
  state-backend:
    type: "rocksdb"
    incremental: true

kafka-source:
  name: "fraud-orders-source"
  bootstrap-servers:
    - "kafka-1.internal.net:9092"
    - "kafka-2.internal.net:9092"
  topics:
    - "orders-v1"
  group-id: "fraud-detector-service"
  starting-offsets: LATEST
  # Universal escape hatch for vendor client tuning & SSL credentials
  properties:
    security.protocol: "SSL"
    ssl.truststore.location: "/var/private/ssl/kafka.truststore.jks"
    # Auto-templated at runtime from host or container environment variables
    ssl.truststore.password: "${KAFKA_TRUSTSTORE_PASSWORD}"
    fetch.max.wait.ms: "500"

alerting:
  threshold-amount: 5000.00
  notification-email: "[email protected]"

3. Fail-fast application bootstrap​

Instead of handwriting hundreds of lines of imperative setup code, Flinkboot bootstraps your entire application in a single statement. Even if you've never configured RocksDB state backends, unaligned checkpoints, latency metrics, or exponential backoff restart strategies before, they are already built-in, pre-tuned for production, and ready to be declared in your YAML with zero plumbing code required.

public static void main(String[] args) throws Exception {
    // 1. Initialize Flinkboot with CLI arguments
    Flinkboot boot = Flinkboot.initialize(args);

    // 2. Load and validate YAML configurations fail-fast into your type-safe record
    AppConfig config = boot.configuration(AppConfig.class);

    // 3. Pre-configured environment: RocksDB, checkpoints, restarts from YAML in one call
    StreamExecutionEnvironment env = boot.executionEnvironment(config.job());

    // 4. Run pipeline
    env.execute(config.job().name());
}

4. Turnkey production connectors​

Instantiating sources and sinks in vanilla Flink requires verbose builders, duplicate properties, and manual schema binding. Flinkboot connector factories create fully tuned sources and sinks directly from your validated configuration objects with native serializer resolution.

// Instantiates a fully configured, production-ready KafkaSource in one line
KafkaSource<OrderEvent> source = KafkaSourceFactory.supplyFor(
    config.kafkaSource(), 
    deserializationSchema
);

5. Native collection & JDK serialization​

In vanilla Flink, collections like List<String> inside a POJO silently fall back to Kryo serialization because Flink's type extractor cannot resolve generic parameters. Flinkboot provides turnkey TypeInfoFactory classes to guarantee high-throughput, native Flink serializers.

public class OrderEvent {
    public String id;

    // Instructs Flink to resolve List<E> natively as Types.LIST(Types.STRING)
    @TypeInfo(ListTypeInfoFactory.class)
    public List<String> tags;
}

6. Build-time POJO compliance auditing​

Apache Flink relies on its high-performance PojoSerializer to achieve maximum streaming throughput. If an event class lacks a default constructor, contains an unmapped collection, or misses getters/setters, Flink silently falls back to slow Kryo serialization without failing. Flinkboot provides build-time assertions to guarantee POJO compliance in your unit tests.

@Test
void verifyOrderEventSerialization() {
    // Build-time guarantee: recursively audits all fields, getters, and constructors
    // Fails the test immediately if any field falls back to Kryo
    FlinkbootAssertions.assertThat(OrderEvent.class)
        .isPojo();
}