Graceful Launches with Feature Toggles

Feature Toggle

Ever deployed a shiny new feature to your production environment, only to be met with unforeseen issues or disgruntled users? Feature flags, also known as feature toggles, come to the rescue! This powerful technique allows you to control the rollout of new functionalities, enabling a smoother transition and data-driven decision making.

This article delves into the world of feature flags, exploring their benefits and implementation using a simple Spring application. Whether you’re a seasoned Java developer or just starting your journey, we’ll guide you through the process of building a robust feature-flagged application.

Imagine a world where you can deploy new features without the pressure of an all-or-nothing launch. Feature flags provide this flexibility by acting as a switch that turns functionalities on or off. This empowers developers to:

• Gradually Roll Out Features: Introduce features to a limited audience (e.g., beta testers) before exposing them to the entire user base. This allows for controlled testing and reduces the risk of widespread disruptions.
• A/B Testing: Experiment with different variations of a feature by directing specific user groups to see alternative implementations. Feature flags make A/B testing a breeze, enabling you to gather valuable data to determine the best user experience.
• Quick Rollbacks: Encountered an unexpected bug? No worries! With feature flags, you can simply disable the faulty functionality without requiring a whole new deployment. This ensures a swift recovery and minimises user impact.

Building a Feature-Flagged Spring Application

Let’s build a simple Spring application that utilizes a feature flag to control the display of a new welcome message. We’ll leverage H2, an in-memory database, to store the feature flag value.

1. Setting up the Project:

• Create a new Spring Boot project using your preferred IDE.
• Add the necessary dependencies for H2 database connection and web development.

2. Feature Flag Model:

Create a FeatureFlag model class to represent the flag information:

import jakarta.persistence.*;
import lombok.Data;
@Entity
@Data
public class FeatureFlag {
    @Id
    private String featureName;
    private boolean featureEnabled;
}

3. H2 Database Configuration:

Configure Spring Boot to use H2 as the embedded database. You can achieve this by adding the following dependency to your build.gradle:

runtimeOnly 'com.h2database:h2'

If you are using maven, you can download H2 from Maven repository

<!-- https://mvnrepository.com/artifact/com.h2database/h2 -->
<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <version>2.2.224</version>
    <scope>test</scope>
</dependency>

4. Feature Flag Repository:

Create a repository interface (FeatureFlagRepository) extending JpaRepository to interact with the FeatureFlag entity in H2.

import com.nitsher.featuretoggle.dto.FeatureFlag;
import org.springframework.data.jpa.repository.JpaRepository;
public interface FeatureFlagRepository extends
             JpaRepository<FeatureFlag, Long> {
    FeatureFlag findByFeatureName(String featureName);
}

5. Feature-Flagged Controller:

Here’s the magic! Create a Spring MVC controller with a method that retrieves the feature flag value from the repository and conditionally returns the appropriate welcome message:

@RestController
public class FeatureController {
    @Autowired
    private FeatureFlagRepository featureFlagRepository;
@GetMapping("/welcome")
    public String getMessage() {
        FeatureFlag featureFlag = featureFlagRepository
                    .findByFeatureName("welcome_message");
        if (featureFlag != null && featureFlag.isFeatureEnabled())
            return "Welcome to new feature toggle application where we have enabled AI " +
                    "capabilities to give you result even before you think ! ";
        return "Welcome to Feature Toggle Application!";
    }
    @PostMapping("/toggleFeature")
    public String toggleFeature() {
        FeatureFlag featureFlag = featureFlagRepository
                    .findByFeatureName("welcome_message");
        if (featureFlag != null) featureFlag
                    .setFeatureEnabled(!featureFlag.isFeatureEnabled());
        else featureFlag = createFeatureFlag("welcome_message");
        featureFlagRepository.save(featureFlag);
        return "Feature toggled successfully!";
    }
    private static FeatureFlag createFeatureFlag(String featureName) {
        FeatureFlag featureFlag;
        featureFlag = new FeatureFlag();
        featureFlag.setFeatureName(featureName);
        featureFlag.setFeatureEnabled(true);
        return featureFlag;
    }
}

6. Running the Application:

Start the Spring Boot application and access the /toggleFeature endpoint to enable and disable the feature. Once done access the /welcome endpoint, the response will display either the new or old welcome message based on the feature flag value stored in H2.

Key Takeaways

Feature flags are a valuable asset for modern application development. They empower developers with granular control over feature rollouts and facilitate data-driven decision making. By implementing feature flags effectively, you can ensure a smooth and successful software delivery process.

This example provides a basic understanding of feature flags in Spring. In production environments, consider utilising robust feature flag management platforms that offer advanced functionalities like user targeting and detailed analytics.

So, the next time you’re itching to deploy a shiny new feature, remember the power of feature flags! They can be your secret weapon for a graceful and controlled launch.

Also, we have used H2 in this article just for a quick POC in real world you might want to use any other persistent database ( it can be any SQL or NoSQL database ).

Follow us for more such content.

P.S. Used feature flags? Share your experience in the comments!