TABLE OF CONTENTS

Industry/News Company Updates Best Practices and How To Languages & Technologies Product Customer Stories

Java Feature Flags and Toggles: A Step-by-Step Guide with a Working Java Application

Abhishek Agarwal

In this tutorial, we'll learn how to use Java feature flags in a real Java application, from a plain HttpServer project through to a working integration with the Flagsmith Java SDK. Along the way, we'll cover what a feature flag actually is, when teams reach for a library versus a platform, and how the same pattern extends to canary releases and A/B testing.

You don’t need any prior experience with feature flags, so let’s dive in.

Introduction to Java feature flags

We'll cover the fundamentals of feature flags and feature toggles, how to build a basic Java server application, and how to integrate Flagsmith's Java SDK to make that application a lot more powerful. So, let's dive deeper into the Java feature flags topic.

What is a feature flag?

Before we get into the development work, let's first understand what feature flags or feature toggles are, and how they help development teams deliver value more quickly.

Feature flags are one of the most important components of any application. They let you modify the functionality of your code without needing a code merge, a redeployment, or any other heavy lifting. Toggling a feature flag generally becomes as simple as clicking a UI button. Feature flags make releases a lot more efficient and a lot lower risk, since rollouts (and rollbacks) become much easier.

Feature flags let you turn some behaviour of your code on or off, or let you alter that behaviour based on the flag's value. As a basic example, say you frequently want to change the price of an article on your website without redeploying code—you could do this with a feature flag in Java. There are a couple of ways feature flagging can be implemented: fetching the value periodically from the server, or fetching the value every time it's required. We'll look at both of these approaches below.

What are some use cases for Java feature flags?

Java feature flags can help with more efficient feature rollouts to customers and are often part of making deployment processes more agile. You can use them for phased and gradual feature rollouts, A/B testing, segmenting releases to different user groups, behaviour experiments, and feature versioning. Wrapping new code in a flag also helps with easier rollbacks if anything goes wrong.

Why use feature flags in Java?

Let's understand this through a simple real-life example.

Imagine you're driving a car and the air conditioner suddenly starts making a weird noise. The first thing you'd try is changing the fan speed or mode, and if that doesn't help, you'd turn it off. Next, you'd reach out to a mechanic, and once the part is fixed, you'd turn the AC back on and continue your journey.

The car maps directly onto how you'd use feature flags when anything goes wrong with your application. The fan speed and modes we talked about are the feature flag values that can be updated. Turning the AC off is the same as disabling the feature flag—it prevents your app's users from seeing a weird or unexpected error screen on that page. Ideally, when the feature flag is disabled, you'd show users a message like "This page is under maintenance, please come back later." Once the issue is fixed, you can re-enable the feature flag.

To get the most out of flags, there are feature toggle best practices you can follow.

Best way to manage feature flags in Java

Multiple solutions exist for managing feature flags in Java, and the best one isn't always obvious—it depends on how big your user base and team are.

Rolling your own. You can manage a feature flag with nothing more than a config file or environment variables, read at startup or on a schedule, and branch your code paths off its value. That works fine for a single service with one or two flags, but it has no UI, no audit trail, and no way to change a flag's value without a deploy or a server restart.
A Java feature management library. Libraries such as Togglz give you a proper feature manager API inside your Java application: strategies for who sees a feature, a basic admin console, and solid Spring Boot support. They're a real step up from rolling your own, but they're Java-only, and the flag state typically still lives inside your own infrastructure, which means more to run and secure yourself.
A hosted or self-hosted feature flag platform. A more sophisticated platform like Flagsmith separates the feature flag from your source code entirely. You connect to a single feature flag provider, manage flags through a UI or API, flip them for one service or ten, and reuse the same flags across Java, Node.js, mobile, or any other part of your stack, all while using the same project and the same rules for who sees what.

For a single Java service, a library is often enough. Once you've got multiple services, multiple environments, or non-Java components, a platform is usually the better solution—it saves you from solving configuration, access, and auditability from scratch for every new feature.

Enterprise-grade Java feature flags for large teams

A single boolean toggle is easy to manage. Dozens of flags across several teams, services, and environments is a different problem.

Large Java teams typically need a few things that a single feature manager class won't give them on its own:

Access control. Not everyone on a large engineering org should be able to flip a flag in production. Role-based access control lets you scope exactly who can change a flag, and in which environment.
An audit trail. When a flag changes behaviour in production, you need to know who changed its value and when, without digging through commit history.
Multi-environment promotion. The same flag needs a safe way to move from development through staging and into production, without manually recreating it in each environment's config.
Support for trunk-based development. Feature flags let large teams merge new code to trunk continuously, while keeping unfinished functionality hidden from the user base behind a disabled flag. This is one of the main reasons feature flags have become a standard software development technique for teams that release often.

A managed feature flag platform earns its keep right here: the infrastructure for access control, audit history, and environment promotion is already built, so your team's time goes into the feature rather than the feature management system around it.

Why Flagsmith?

Flagsmith provides a free, all-in-one platform for building and managing your feature flags, start to finish. It lets you store values inside a flag so you can toggle multiple kinds of behaviour, as covered in the use cases section above.

Flagsmith is an open-source tool, which makes it easy to trust and audit.

It also provides well-documented support for multiple programming languages across web, mobile, and server-side applications, with a simple UI that lets you change your application's behaviour without needing to understand Flagsmith's internal implementation at all.

Let's get started with Java feature toggles!

As a first step, we need to create an account on Flagsmith. Fill in your details on the sign-up page, as shown below.

Next, Flagsmith will either ask you to name your organisation or create one for you automatically. If you see the form, name it whatever you like. I've called mine Java Feature Flag WebServer Tutorial. Leave the hosting option set to "Public SaaS (Multi Tenant)" and click "Create Organisation".

Now we need a project inside this organisation. From the "Welcome to Flagsmith" page, click "Projects", then click the "Create Project" card. Enter a project name in the side panel that opens and create it. I'm using Java Feature Flag WebServer.

Congratulations, you've completed the Flagsmith setup process. You should see a screen like the one below.

We'll come back to this screen when we want to add a feature flag to our application. Now, let's start building a Java web server application.

Let's code!

To keep this tutorial simple, we'll create a rudimentary Java server application. It'll be exposed on localhost and use local system storage. This server maintains a list of books and exposes two APIs: one to add a new book, and one to query the books in its records.

If you don't have Java installed, download and install the latest stable version for your OS and system specifications.

Step 1: Java setup

Make sure you have Java installed by running this command in your terminal:

^{java -version}

I'm using the latest LTS release, Java 25, so I'm getting output confirming that version—yours will show whichever JDK you have installed.

Step 2: Create a blank Maven / Gradle project

Most modern IDEs let you create a Maven or Gradle project in a few clicks. Here, I'm creating a Maven project in IntelliJ IDEA.

In the "New Project" window, choose "Maven" and select the JDK you installed in Step 1. Then open "Advanced Settings" and set the GroupId to ^{org.flagsmith}, so it matches the package name used in this tutorial's code.

Once the project opens, click "Load Maven Project" when IntelliJ prompts you. The image below shows the directory structure it creates automatically. The ^Main.java file contains a basic "Hello and welcome!" program. IntelliJ's project panel hides the ^.java extension, so you'll see this file listed simply as ^Main.

Step 3: Use the ^HttpServer library to create a basic HTTP server

We'll expose port 8000 with a single endpoint. Replace everything in ^Main.javawith the code below. It exposes ^{localhost:8000/test} and returns "This is the response" with a status code of 200.

package org.flagsmith;

import com.sun.net.httpserver.HttpExchange;
import com.sun.net.httpserver.HttpHandler;
import com.sun.net.httpserver.HttpServer;
import java.io.IOException;
import java.io.OutputStream;
import java.net.InetSocketAddress;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpServer server = HttpServer.create(new InetSocketAddress(8000), 0);
        server.createContext("/test", new MyHandler());
        server.setExecutor(null); // creates a default executor
        server.start();
    }

    static class MyHandler implements HttpHandler {
        @Override
        public void handle(HttpExchange t) throws IOException {
            String response = "This is the response";
            t.sendResponseHeaders(200, response.length());
            OutputStream os = t.getResponseBody();
            os.write(response.getBytes());
            os.close();
        }
    }
}

Run your application by clicking the green "Run" button in your IDE. You can verify it's working by hitting the ^test endpoint via curl from your terminal:

^{curl localhost:8000/test}

Step 4: Add GET and POST handlers

In ^Main.java, replace the ^handle function inside ^MyHandler with the code below, so it calls the right method for each request type. GET and POST requests share the same endpoint, and we'll fill in both new methods in the steps that follow.

@Override
public void handle(HttpExchange t) throws IOException {
    if ("GET".equals(t.getRequestMethod())) {
        handleGetBooksRequest(t);
    } else if ("POST".equals(t.getRequestMethod())) {
        handlePostBooksRequest(t);
    }
}

private void handleGetBooksRequest(HttpExchange t) throws IOException {
}

private void handlePostBooksRequest(HttpExchange t) throws IOException {
}

Step 5: Create a Book class to structure the data

Here we're creating a ^Book class with four attributes: ^id, ^title, ^author, and ^price. It needs to live in the same folder as ^Main.java, so right-click the ^{org.flagsmith} folder, choose "New > Java Class", and name it Book. Then paste in the code below, which also adds getters, setters, and a constructor.

package org.flagsmith;

public class Book {
    String id;
    String title;
    String author;
    String price;

    public Book(String id, String title, String author, String price) {
        this.id = id;
        this.title = title;
        this.author = author;
        this.price = price;
    }

    public String getId() { return id; }
    public void setId(String id) { this.id = id; }

    public String getTitle() { return title; }
    public void setTitle(String title) { this.title = title; }

    public String getAuthor() { return author; }
    public void setAuthor(String author) { this.author = author; }

    public String getPrice() { return price; }
    public void setPrice(String price) { this.price = price; }
}

Step 6: Populate dummy data

First, we need some dummy book data. We'll keep it in a global ^books variable, which stores both new and existing books. Start by adding these two imports at the top of ^Main.java:

import java.util.ArrayList;
import java.util.List;

Then declare the variable inside the ^Main class, just above the ^main method:

static List<Book> books = new ArrayList<>();

Add the function below inside the ^Main class to populate the list with three books:

private static void populateDummyData() {
    books.add(new Book("1", "Harry Potter", "J.K. Rowling", "20.99"));
    books.add(new Book("2", "War and Peace", "Leo Tolstoy", "26.99"));
    books.add(new Book("3", "The Kite Runner", "Khaled Hosseini", "30.99"));
}

Your ^main method should now look like this:

public static void main(String[] args) throws Exception {
    HttpServer server = HttpServer.create(new InetSocketAddress(8000), 0);
    server.createContext("/books", new MyHandler());
    server.setExecutor(null); // creates a default executor
    populateDummyData();
    server.start();
}

Note that the endpoint name has been updated to ^books.

Step 7: Complete the GET endpoint

We need to add the Gson library, which makes converting between strings and JSON much easier. Open ^pom.xml and paste the block below directly after the ^properties section:

<dependencies>
    <dependency>
        <groupId>com.google.code.gson</groupId>
        <artifactId>gson</artifactId>
        <version>2.15.0</version>
    </dependency>
</dependencies>

Then reload Maven so IntelliJ downloads the library. Click the floating Maven icon near the top right of the editor, or the reload icon in the "Maven" panel on the right.

Update the ^{handleGetBooksRequest} implementation to return the books list we populated above, with a 200 response code. Add this import to ^Main.java:

import com.google.gson.Gson;
private void handleGetBooksRequest(HttpExchange t) throws IOException {
    OutputStream os = t.getResponseBody();
    String json = new Gson().toJson(books);
    t.sendResponseHeaders(200, json.length());
    os.write(json.getBytes());
    os.close();
}

Run the application and test it from your terminal:

^{curl localhost:8000/books}

You should see all the books we populated above in the response.

Step 8: Complete the POST endpoint

Our POST endpoint should let us add new books to our existing collection, one book at a time. Add these imports at the top of ^Main.java:

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;

Handling the POST request looks like this. We'll print "book added successfully" once the book's been added:

private void handlePostBooksRequest(HttpExchange t) throws IOException {
    Book book = getBookFromRequest(t);
    books.add(book);
    OutputStream os = t.getResponseBody();
    String resp = "book added successfully";
    t.sendResponseHeaders(200, resp.length());
    os.write(resp.getBytes());
    os.close();
}

We need a utility function to parse the request and extract a ^book object from it:

private static Book getBookFromRequest(HttpExchange t) throws IOException {
    InputStreamReader isr = new InputStreamReader(t.getRequestBody(), StandardCharsets.UTF_8);
    BufferedReader br = new BufferedReader(isr);
    String query = br.readLine();
    Gson gson = new Gson();
    return gson.fromJson(query, Book.class);
}

Run the application and try the POST request below to add a book titled "Famous Five":

curl -X POST -H "Content-type:application/json" "http://localhost:8000/books" -d "{\"id\": \"4\",\"title\": \"Famous Five\",\"author\": \"Enid Blyton\",\"price\": 20}"

The terminal should show "book added successfully". Since this book is now in global storage, hitting the GET endpoint should now return four books in total.

Step 9: Add the power of Flagsmith Java feature flag software

With Flagsmith, we can control a variety of components in our web server. Let's imagine we don't want to allow adding new books for a certain period. The naive way to handle this is to edit the code, add logic to stop adding new books, then remove that logic once we want to allow it again.

What if this could be done with the click of a button instead? Flagsmith lets us do that with a minimal, one-time configuration. We'll create a new feature that stops users from adding new books when it's turned off.

Head back to the Flagsmith UI and click "Create Feature" on the screen we left off on. Add a new feature flag named ^add_books—this will control whether we allow adding new books. Set "Enabled by default" to true, as shown below.

You can leave the value blank for now; we'll come back to it later. Click "Create Feature" (make sure it's enabled, not set to false). The UI should now show the flag present in your project:

We'll also need a Flagsmith server-side environment key to initialise the feature flag client. Click "SDK Keys" in the left-hand menu, then click "Create Server-side Environment Key" and give it a name, such as ^java-demo.

Flagsmith hides the key behind dots. Click the copy icon next to it and keep it somewhere private, because you’ll need it in the next step. The key starts with ^ser., followed by a string of letters and numbers.

Step 10: Integrate Flagsmith with your application

Flagsmith provides a Java SDK that’s easy to integrate. Open ^pom.xml and add the dependency below inside the ^dependencies block, directly after the Gson dependency:

<dependency>
    <groupId>com.flagsmith</groupId>
    <artifactId>flagsmith-java-client</artifactId>
    <version>8.3.0</version>
</dependency>

Then reload Maven, as you did in Step 7.

Or, for a Gradle project:

^{implementation 'com.flagsmith:flagsmith-java-client:8.3.0'}

Add these imports at the top of Main.java:

import com.flagsmith.FlagsmithClient;
import java.util.Properties;
import java.io.*;

We first need to add the API key we copied above to a properties file. Right-click the ^{src/main/resources} folder, choose "New > File", and name it ^{config.properties}. Add one property, replacing the placeholder with your key:

^{apiKey=ser.********}

If you're using Git, add ^{config.properties} to your ^.gitignore file, so your key never ends up in your repository.

The utility function below reads the API key from the properties file. Add it inside the Main class, after the ^{populateDummyData} function. In a production application, a helper method like this should live in its own utility class, such as ^{FeatureFlagService.java}.

private static String readFlagsmithApiKey() {
    Properties prop = new Properties();
    String propFileName = "config.properties";
    // if this does not work, use propFileName = "resources/config.properties"
    InputStream inputStream = ClassLoader.getSystemResourceAsStream(propFileName);
    if (inputStream != null) {
        try {
            prop.load(inputStream);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    } else {
        throw new RuntimeException("config file input stream is null");
    }
    return prop.getProperty("apiKey");
}

Directly below it, add this function, which initialises the Flagsmith client:

private static FlagsmithClient getFlagsmithClient() {
    String apiKey = readFlagsmithApiKey();
    return FlagsmithClient.newBuilder()
        .setApiKey(apiKey)
        .build();
}

Next, create a global Flagsmith client variable that all the handlers can use. Add it inside the ^Main class, directly below the ^books variable:

public class Main {
    static List<Book> books = new ArrayList<>();
    static FlagsmithClient fsClient;
    // rest of the code follows

Then initialise ^fsClient inside the ^main method, directly after ^{populateDummyData();}. It must be initialised before the server starts. Your ^main method should now look like this:

public static void main(String[] args) throws Exception {
    HttpServer server = HttpServer.create(new InetSocketAddress(8000), 0);
    server.createContext("/books", new MyHandler());
    server.setExecutor(null); // creates a default executor
    populateDummyData();
    fsClient = getFlagsmithClient();
    server.start();
}

Step 11: Use the Java feature toggle to control API behaviour

We'll now modify our POST request handler so it only allows adding new books when the feature flag is enabled. First, add two more imports at the top of ^Main.java:

import com.flagsmith.exceptions.FlagsmithClientError;
import com.flagsmith.models.Flags;

Then, inside ^MyHandler, replace the ^{handlePostBooksRequest} function with this version:

private void handlePostBooksRequest(HttpExchange t) throws IOException {
    boolean allowAddBooks;
    try {
        Flags flags = fsClient.getEnvironmentFlags(); // get all environment flags
        allowAddBooks = flags.isFeatureEnabled("add_books"); // check value of add_books flag
    } catch (FlagsmithClientError e) {
        throw new RuntimeException(e);
    }

    String resp;
    int respCode;
    if (allowAddBooks) {
        // allow adding books only if the feature flag returns true
        Book book = getBookFromRequest(t); // parse book data from the request
        books.add(book);
        resp = "book added successfully";
        respCode = 201;
    } else {
        resp = "method not allowed. Please come back later";
        respCode = 405;
    }

    OutputStream os = t.getResponseBody();
    t.sendResponseHeaders(respCode, resp.length());
    os.write(resp.getBytes());
    os.close();
}

By default, the feature flag is on, so we should be able to add a new book. Run the application and try the POST request below:

curl -X POST -H "Content-type:application/json" "http://localhost:8000/books" -d "{\"id\": \"4\",\"title\": \"Famous Five\",\"author\": \"Enid Blyton\",\"price\": 20}"

You should see a success message, and the book gets added.

Now, try turning the ^add_books feature off. In the Flagsmith UI, click its toggle in the "Features" list. A "Toggle Feature" pop-up asks you to confirm the change, so click "Confirm".

Trying the same POST request now gives the error message "method not allowed. Please come back later".

With just one click, we changed our application's functionality entirely—no redeployment or code change required. That's the power Flagsmith gives you.

Step 12: Leveraging Java feature toggle values

While creating our new feature, we saw an option to add a feature value. Let's see how that can be useful.

Say, due to some requirement, we only want to accept books priced above $20 to avoid filling our library with cheap, low-selling books and to keep a consistent standard. We want to vary this threshold price based on demand and staff capacity, and amending the code every time isn't feasible.

Go ahead and set the feature flag's value to 20. In the "Features" list, click ^add_books to open the "Edit Feature" panel. Turn the "Enabled" toggle back on so we can keep testing, type ²⁰ in the "Value" field, and click "Update Feature Value", as shown below.

We need to update our code to also read the feature flag's value and act on it. First, define a constant for the flag's name. Add this line inside the Main class, directly below the ^fsClient variable:

^{static final String ADD_BOOKS_FEATURE_FLAG = "add_books";}

Then replace handlePostBooksRequest with this version:

private void handlePostBooksRequest(HttpExchange t) throws IOException {
    boolean allowAddBooks;
    int minPrice;
    try {
        Flags flags = fsClient.getEnvironmentFlags(); // get all environment flags
        allowAddBooks = flags.isFeatureEnabled(ADD_BOOKS_FEATURE_FLAG); // check value of add_books flag
        minPrice = Integer.parseInt(String.valueOf(flags.getFeatureValue(ADD_BOOKS_FEATURE_FLAG))); // get minimum price of book that can be added
    } catch (FlagsmithClientError e) {
        throw new RuntimeException(e);
    }

    String resp;
    int respCode;
    if (allowAddBooks) {
        // allow adding books only if the feature flag returns true
        Book book = getBookFromRequest(t); // parse book data from the request
        if (Double.parseDouble(book.price) >= minPrice) {
            books.add(book);
            resp = "book added successfully";
            respCode = 201;
        } else {
            resp = "book value less than minimum price allowed";
            respCode = 406;
        }
    } else {
        resp = "method not allowed. Please come back later";
        respCode = 405;
    }

    OutputStream os = t.getResponseBody();
    t.sendResponseHeaders(respCode, resp.length());
    os.write(resp.getBytes());
    os.close();
}

Note two things here. The new ifcondition checks whether the book's price meets our minimum price, adding the book to the list if it does and returning an error if it doesn't. We also convert the flag's value to text with ^{String.valueOf} before reading it as a number, because the SDK can return it as either, depending on the evaluation mode. We'll switch modes in Step 13, so this keeps the code working there. ^{Double.parseDouble} lets book prices include decimals, such as 20.99.

Make sure to re-run the application after making these code changes, then test both cases:

Adding a book priced at $25 (should work):

curl -X POST -H "Content-type:application/json" "http://localhost:8000/books" -d "{\"id\": \"4\",\"title\": \"Famous Five\",\"author\": \"Enid Blyton\",\"price\": 25}"

Adding a book priced at $15 (should return an error):

curl -X POST -H "Content-type:application/json" "http://localhost:8000/books" -d "{\"id\": \"4\",\"title\": \"Famous Five\",\"author\": \"Enid Blyton\",\"price\": 15}"

Both results are as expected: the first request succeeds, and the second returns an error.

Step 13: Flagsmith local evaluation mode

We just saw that every POST request makes an additional API call to fetch the feature flag's value. That's an expensive operation at scale, especially if your server handles thousands or millions of requests per minute.

Local evaluation mode solves exactly this. With it, the feature flag value is fetched periodically on a defined interval (say, once a minute), so your application doesn't call the Flagsmith server on every request. That saves a meaningful amount of time per request in large-scale systems.

One thing to keep in mind: local evaluation mode doesn't let your application react to a flag change instantly. It shouldn't be used where you're dealing with financial data or other millisecond-sensitive updates—a change takes up to the length of your refresh interval to reflect in your code.

Let's measure the difference. First, we need a baseline without local evaluation, so we'll write a basic Python script that fires 50 POST requests in succession. You'll need Python 3 and the ^requests library. If ^requests isn't installed, run ^{python3 -m pip install requests}. Save the script below as ^{test_requests.py}:

import requests
import time

data = {
    'id': '4',
    'title': 'Test book',
    'author': 'Betty Carter',
    'price': 49.99,
}

start = time.time()
for i in range(50):
    x = requests.post('http://localhost:8000/books', json=data)
end = time.time()

print("Total time taken: ", end - start)

With your application still running from Step 12, run the script from your terminal:

^{python3 test_requests.py}

If you're using the version of Python that comes with macOS, you may see a ^{NotOpenSSLWarning} before the result. It's harmless here, because the script only talks to your own machine.

Now let's switch on local evaluation with a one-minute refresh. Add this import at the top of ^Main.java:

^{import com.flagsmith.config.FlagsmithConfig;}

Then replace the ^{getFlagsmithClient} function with this version:

private static FlagsmithClient getFlagsmithClient() {
    String apiKey = readFlagsmithApiKey();
    FlagsmithConfig flagsmithConfig = FlagsmithConfig.newBuilder()
            .withLocalEvaluation(true)
            .withEnvironmentRefreshIntervalSeconds(60)
            .build();
    return FlagsmithClient.newBuilder()
            .setApiKey(apiKey)
            .withConfiguration(flagsmithConfig)
            .build();
}

Restart the application and wait a few seconds for it to download your flags. You may see three warning lines beginning with ^SLF4J in IntelliJ. They just mean no logging library is set up, and you can safely ignore them. Then run the script again.

Without local evaluation, the 50 requests took around 2 seconds on my machine. With it, they took around 0.1 seconds, roughly 20 times faster. Your numbers will vary with your connection, but the gap should be just as clear. For servers handling heavy load, that saving adds up quickly.

Java feature flags for safe canary releases

The same ^{isFeatureEnabled} pattern we used for ^add_books extends naturally to a canary release. Instead of flipping a flag on for everyone at once, you enable it for a small percentage of users, a single environment, or a specific user segment first, then widen the rollout once you're confident the change behaves as expected in production.

In practice, this means wrapping the new code path behind a flag exactly as we did with the ^add_books handler, but targeting the flag at a defined segment rather than toggling it globally. If something goes wrong, you disable the flag for that segment—not the whole user base—and the rest of your users never see the regression. This is one of the clearest wins of using feature flags in Java over a traditional all-or-nothing deployment: the blast radius of a bad release shrinks to whichever segment you chose to test with.

Java feature flags for A/B testing and experiments

The feature value pattern we used to set a minimum book price works the same way for an experiment. Instead of a single value shared by every user, you can serve different values of the same flag to different user segments, then compare how each group behaves.

For example, you could use a feature flag's value to show one price threshold to half your user base and a different threshold to the other half, then feed the results from each group into your analytics to see which performs better. The code change is minimal—it's the same ^{getFeatureValue} call we already used—the difference is in how the flag is configured and targeted on the Flagsmith side, rather than in new application code.

Conclusion

In this step-by-step guide, we walked through using feature flags in a Java application, from a plain ^HttpServer project to a full integration with the Flagsmith Java SDK. Feature flags give you a lot of control and agility in your software development process, lowering the risk of releases thanks to easier rollbacks, safer canary releases, and the ability to run real experiments without redeploying code.

Get Started

If you like this Java feature flag guide, check out our SDK list (including the Java SDK), or get started with a free account to try feature flagging.

Why Flagsmith?

It's free to start, so you can try feature flags right away.
Flagsmith is open-source, which makes it trustworthy—you can look through the code, check the roadmap, and raise issues if you notice anything. Transparency is one of the biggest benefits of choosing an open-source feature flag platform.
Flexible deployment options, including the ability to deploy on-premises, so you keep control of your flags and infrastructure.
Flagsmith offers integrations with CI/CD tools, A/B testing and analytics tools, and more, so it fits within your current workflows and tech stack rather than adding another decision point.

Java feature flags FAQs

How do I implement feature flags in a Java application?

Wrap the code path you want to control in a conditional that checks a flag's value, rather than hardcoding the behaviour. You can read that value from a config file or environment variable for a single, simple flag, from a Java feature management library such as Togglz for more structure, or from a platform like Flagsmith's SDK, as shown throughout this guide, when you want a UI and targeting without a redeploy.

Does Flagsmith work with Spring Boot?

Yes. The walkthrough in this guide uses a plain ^HttpServer application to keep the setup simple and dependency-free. Still, the same ^{flagsmith-java-client} dependency and client initialisation pattern drop into a Spring Boot application in the same way—you'd typically wrap the ^{FlagsmithClient} in a Spring bean. So you can inject it into any controller or service that needs to check a flag.

Is there a difference between a feature flag and a feature toggle in Java?

Not really. Whether you search for feature flags Java or feature toggle Java, you'll land on the same software development technique: a switch, typically backed by a configuration value, that changes your code's behaviour without a new deployment. "Feature flag" and "feature toggle" are used interchangeably across the Java ecosystem and throughout this guide.