Releases · launchdarkly/java-core

04 Feb 22:05

github-actions

launchdarkly-java-server-sdk-7.11.0

bfde41d

launchdarkly-java-server-sdk: v7.11.0 Latest

Latest

7.11.0 (2026-02-04)

Features

experimental: Release EAP support for FDv2 data system. (6d7000b)

Data Saving Mode EAP

This release adds support for our second generation flag delivery protocol, also known as data-saving mode.

This SDK version uses the first generation flag delivery protocol unless you explicitly configure the new protocol.

Support for the new protocol is defined by a data system configuration. Setting a data system via Components.dataSystem() enables the new protocol.

The data system supports more flexible configuration for initializers (how the SDK gets an initial payload) and synchronizers (how it stays up to date).

Configuration

Several predefined data system configurations are available depending on how you run the SDK.

Default

This is the LaunchDarkly-recommended default. It uses a two-phase strategy for initialization and includes fallbacks for synchronization.

The SDK gets an initial payload with a single request to our polling endpoints, then keeps it up to date via streaming. If that initial request fails, the SDK can still initialize via streaming once it enters the synchronization phase. During synchronization, it can fall back to polling if streaming has problems.

LDConfig config = new LDConfig.Builder()
    .dataSystem(Components.dataSystem().defaultMode())
    .build();

Polling only or streaming only

You can configure the SDK to use only polling or only streaming. This is not the recommended mode, and fewer fallbacks are available.

Polling:

LDConfig config = new LDConfig.Builder()
    .dataSystem(Components.dataSystem().polling())
    .build();

Streaming:

LDConfig config = new LDConfig.Builder()
    .dataSystem(Components.dataSystem().streaming())
    .build();

In streaming-only mode, polling may still be used if we need to disable the second generation protocol. In that case the data system is told to fall back to our v1 protocol and uses polling to do so.

With a persistent store

With a persistent store configured, the SDK uses the same initialization and synchronization strategy as the default mode, plus a persistent store.

If flags are evaluated before the SDK has finished initializing, cached values from the store can be used. After initialization, flags are kept in an in-memory cache and written to the store. Flags remain in memory after initialization, unlike the previous implementation which used a TTL per item.

When using a persistent store you need a persistence integration (for example the Redis store integration).

Using a Redis persistent store:

import com.launchdarkly.sdk.server.integrations.Redis;

LDConfig config = new LDConfig.Builder()
    .dataSystem(Components.dataSystem()
        .persistentStore(Components.persistentDataStore(Redis.dataStore())))
    .build();

Daemon mode

In daemon mode the SDK does not request a flag payload from LaunchDarkly. It relies on a persistent store that is populated by the Relay Proxy.

Configuration is read from the store on demand and cached in memory with a TTL. The TTL controls how fresh the data is for each item.

Using a Redis persistent store:

import com.launchdarkly.sdk.server.integrations.Redis;

LDConfig config = new LDConfig.Builder()
    .dataSystem(Components.dataSystem()
        .daemon(Components.persistentDataStore(Redis.dataStore())))
    .build();

Offline

The top-level offline configuration applies to the data system.

LDConfig config = new LDConfig.Builder()
    .offline(true)
    .build();

If both offline(true) and a data system (e.g. Components.dataSystem().defaultMode()) are set, the data system's initializers and synchronizers are not used.

LDConfig config = new LDConfig.Builder()
    .offline(true)
    .dataSystem(Components.dataSystem().defaultMode())
    .build();

Custom Configuration

For advanced use cases, you can build a custom data acquisition strategy:

LDConfig config = new LDConfig.Builder()                                                             
    .dataSystem(Components.dataSystem().custom()                                                     
        .initializers(DataSystemComponents.pollingInitializer())                                     
        .synchronizers(                                                                              
            DataSystemComponents.streamingSynchronizer(),                                            
            DataSystemComponents.pollingSynchronizer()                                               
        )                                                                                            
        .fDv1FallbackSynchronizer(DataSystemComponents.fDv1Polling()))                               
    .build();                                                                                        
                                                                                                     
LDClient client = new LDClient("your-sdk-key", config);

The data system does not require Components.externalUpdatesOnly(). The equivalent with the data system is to not specify any initializers, synchronizers, or fallback synchronizer.