Forem: Chanuka Dinuwan

Building a GraphQL API with Spring Boot: A Complete Guide

Chanuka Dinuwan — Fri, 23 May 2025 19:17:45 +0000

In modern API development, Eve``ryone focuses on flexibility and efficiency. Traditional REST APIs often lead to over- or under-fetching of data, especially in complex systems with deeply nested relationships. Graphql, a query language developed by Facebook, addresses these issues by allowing clients to request the exact data they need.

When combined with Spring Boot, a powerful Java-based framework for building Microservices, GraphQL becomes a robust solution for building flexible, scalable APIs. This blog discusses how to integrate GraphQL with Spring Boot, allowing you to build APIs that are not only performant and type-safe but also developer-friendly and adaptable to changing client requirements.

GraphQL Documentation: https://graphql.org

GraphQL with Spring Boot Documentation: https://spring.io/guides/gs/graphql-server

GraphQL vs Rest

Rest has been the standard architectural style for building APIs for years now, GraphQL offers a modern alternative designed for flexibility and efficiency in data retrieval. The table below summarizes the key differences between the two approaches:

Set up Spring Boot Application

We need to use a GraphQL maven or gradle dependency to implement the Spring boot application with GraphQL.

` <dependency> <groupId>org.springframework.graphql</groupId> <artifactId>spring-graphql-test</artifactId> <scope>test</scope> </dependency> `
We need to create a simple Spring Boot application to try this or you can clone it here:

https://github.com/cdin8619-0/graphql-springboot.git

Project Structure

Let’s dive into the main component of our application:

Entity classes
Repository interfaces
Service classes
Controllers with GraphQL annotations
GraphQL schema definition
Controller implementation

Controller implementation

`
@Controller
public class ProductController {

private ProductService productService;

@Autowired
public ProductController(ProductService productService) {
    this.productService = productService;
}

@QueryMapping
public List<Product> getProducts() {
    return productService.getAllProducts();
}

@QueryMapping
public List<Product> getProductsByCategory(@PathVariable String category) {
    return productService.getProductsByCategory(category);
}

@MutationMapping
public Product updateStock(@Argument int productId, @Argument int stock) {
    return productService.updateStock(productId, stock);
}

@MutationMapping
public Product receiveNewShipment(@Argument int productId, @Argument int quantity) {
    return productService.receiveNewShipment(productId, quantity);
}

}
`

The @QueryMapping and @MutationMapping annotations in Spring for GraphQL simplify linking methods to GraphQL query and mutation fields. They are concise alternatives to @SchemaMapping:

@QueryMapping: Maps a method to a GraphQL query field, typically using the method name.
@MutationMapping: Maps a method to a GraphQL mutation field for handling data changes.

Service Implementation

This is the place where we write logic. This is the same as the normal Spring Boot applications.

`
@Service
public class ProductService {

@Autowired
private ProductRepository productRepository;

public List<Product> getAllProducts() {
    return productRepository.findAll();
}

public List<Product> getProductsByCategory(String category) {
    return productRepository.findByCategory(category);
}

public Product updateStock(int id , int stock) {
    Product existingProduct = productRepository.findById(id).orElseThrow(() -> new RuntimeException("Product not found"));

    existingProduct.setStock(stock);
    return productRepository.save(existingProduct);
}

public Product receiveNewShipment(int id , int quantity) {
    Product existingProduct = productRepository.findById(id).orElseThrow(() -> new RuntimeException("Product not found"));

    existingProduct.setStock(existingProduct.getStock() + quantity);
    return productRepository.save(existingProduct);
}

}
`

GraphQL Schema Definition

Our application needs to define the schema that describes our data model and operations. Create a file named schema.graphqls in the src/main/resources/graphql directory:

`
type Product {
id: ID,
name: String,
category: String,
price: Float,
stock: Int
}

type Query {
getProducts: [Product]
getProductsByCategory(category: String): [Product]
}

type Mutation {
updateStock(productId: ID, stock: Int): Product
receiveNewShipment(productId: ID, quantity: Int): Product
}
`

Entity Class and Repository Implementation

`
@Entity
@data
@NoArgsConstructor
@AllArgsConstructor
public class Product {

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private int id;

private String name;
private String category;
private float price;
private int stock;

}
`

` @Repository public interface ProductRepository extends JpaRepository<Product, Integer> { List<Product> findByCategory(String category); } `

I created a data loader class to load initial data to the application.

Add the following properties to application.properties(or application.yml):

`
spring.application.name=graphql-springboot
server.port=9090

Database configuration

spring.datasource.url=jdbc:h2:mem:productdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
spring.h2.console.enabled=true
spring.datasource.auto-create=true

GraphQL endpoint path (default is /graphql)

spring.graphql.path=/graphql

Enable GraphiQL

spring.graphql.graphiql.enabled=true
spring.graphql.graphiql.path=/graphiql
`

Database configuration may be different for yours than mine. But add the above-mentioned GraphQL configurations to your application.

Testing with GraphiQL

Spring Boot with GraphQL provides an integrated GraphiQL interface for testing GraphQL queries. After running the application, navigate to http://localhost:8080/graphiql to interact with your API. There you can play with application GraphQL APIs.

Here are some sample queries and mutations:

`
Get All Products
graphqlquery {
getProducts {
id
name
category
price
stock
}
}

Get Products by Category
graphqlquery {
getProductsByCategory(category: "Electronics") {
id
name
price
stock
}
}

Update Product Stock
graphqlmutation {
updateStock(productId: 1, stock: 25) {
id
name
category
stock
}
}

Receive New Shipment
graphqlmutation {
receiveNewShipment(productId: 2, quantity: 10) {
id
name
category
stock
}
}
`

You can also use a Postman or a similar tool to test your GraphQL application.

Error Handing in GraphQL

GraphQL has a different approach to error handling compared to REST. Let’s enhance our application with proper error handling.

`
package com.example.graphqlspringboot.exception;

import graphql.GraphQLError;
import graphql.GraphqlErrorBuilder;
import graphql.schema.DataFetchingEnvironment;
import org.springframework.graphql.execution.DataFetcherExceptionResolverAdapter;
import org.springframework.stereotype.Component;

@Component
public class GraphQLExceptionHandler extends DataFetcherExceptionResolverAdapter {

@Override
protected GraphQLError resolveToSingleError(Throwable ex, DataFetchingEnvironment env) {
    return GraphqlErrorBuilder.newError()
            .message(ex.getMessage())
            .path(env.getExecutionStepInfo().getPath())
            .location(env.getField().getSourceLocation())
            .build();
}

}
`

Advanced Features

DataLoaders for Batch Loading

You might face the “N+1 queries” problem when dealing with complex data relationships. GraphQL DataLoaders help solve this issue by batching and caching requests:

`
@Component
public class ProductDataLoader {

private final ProductRepository productRepository;

public ProductDataLoader(ProductRepository productRepository) {
    this.productRepository = productRepository;
}

@SchemaMapping(typeName = "Query", field = "productsByIds")
public List<Product> getProductsByIds(@Argument List<Integer> ids) {
    return productRepository.findAllById(ids);
}

}
`

Subscriptions for Real-time Update

GraphQL also supports subscriptions for real-time updates. Let’s add a simple stock level subscription:

// In GraphQL schema
type Subscription {
stockLevelChanged: Product
}

// In Java code
@SubscriptionMapping
public Publisher stockLevelChanged() {
return productPublisher;
}

Security Considerations

When implementing GraphQL APIs, consider these security aspects:

Query Complexity Analysis: Prevent resource-exhausting queries
Rate Limiting: Control the frequency of requests
Authentication and Authorization: Protect sensitive operations
Input Validation: Validate all client inputs

Performance Optimization

For optimal GraphQL performance:

Query Depth Limiting: Prevent deeply nested queries
Result Size Limiting: Control response payload sizes
Caching: Implement response caching
Pagination: Use cursor-based pagination for large result sets

Conclusion

GraphQL with Spring Boot offers a powerful alternative to traditional REST APIs, providing clients with the flexibility to request exactly the data they need. The strong typing, self-documenting nature, and single endpoint approach make it an excellent choice for modern applications with complex data requirements.

By implementing GraphQL in your Spring Boot applications, you can:

Reduce over-fetching and under-fetching of data
Create better developer experiences with strong typing and tooling
Enable clients to evolve independently of the server
Simplify API versioning
Build more responsive and efficient applications

The example provided in this article demonstrates basic GraphQL concepts with Spring Boot, but you can extend it with more complex features like relationships between entities, pagination, filtering, and advanced security measures.

Remember that GraphQL is not a replacement for REST in all cases — choose the approach that best fits your specific application requirements and constraints.

Happy coding!🚀

Organize Your Cloud Environment with AWS My Applications

Chanuka Dinuwan — Mon, 21 Apr 2025 12:38:26 +0000

My application is a feature that helps organize and manage resources in the AWS cloud. In the AWS console, we can view my application widget as follows:

Below is a summary of the features provided by My Applications:

Organising Resources: Let’s say you’re developing an application that utilises various AWS services, including SQS queues, EC2 instances, and DynamoDB databases. This collaborative effort paves the way for a more convenient method to view all the information of a particular application by using My Applications instead of managing each system separately.
Centralised Examine: My Application maintains a centralised facade that allows users to look up all the application-related resources they need without the hassle of browsing through all the AWS services to select those they require. Additionally, this will reduce waiting times, enabling quicker and easier document processing.
Simplified Management: The My Apps feature ensures minimal effort is involved in adding resources to existing applications or creating new applications from scratch. You can also apply tags to sort filters and resources, which simplifies managing permissions across the application.
Improved Organisation: The introduMygement program introduces more regulation to your cloud, making it easier to manage resources based on function, project, or any other desired attribute. This results in simpler and more organiZed cloud management.

Let's go through the demo on how to create AWS my application using the AWS console.

When you click the “Create application” button in the widget, you will be redirected to this page where you can provide the application name and description. If you want to add a unique tag from yourself, you can do that as well.

When we click the next button this will redirect us to the page where we can add existing resources to our application. This part is optional if you want to create a new application using existing resources you can use this.

To use this, you need to enable AWS Resources Explorer. It is a free service. I’m now going to use existing resources to create an application. So, I clicked the “Select Resources” button. Then, it will display a window like this:

Then I added those resources to my application:

Then let's create the application:

Now, here you can see the application named demo in my application widget:

Once we click that you can see the cost for the application, resource consumption, security, monitoring and many more application-wise. And also, you can customise your dashboard, customise it we can set specific alerts too.

What You Can Do With My Applications:

Get the data on the application charges, throughput, security, and monitoring.
Make your dashboard personalised and for user-friendly access to the data that you need to see instantly.
Create cloud resource management alerts based on the specific application. Scan the utilization regularly for timely action.
Using My Apps, you will enjoy greater organization, control, and visibility.

Happy Coding 🚀!

What I learned from Vibe Coding

Chanuka Dinuwan — Fri, 18 Apr 2025 18:37:57 +0000

Software development is changing rapidly, and a new way of coding is becoming popular. It’s called “vibe coding,” a term used by Andrej Karpathy. This isn’t about how code appears or feels. It’s about leveraging AI to handle the majority of the heavy lifting in code writing. Developers who use AI can complete 26% more work, and they’re able to finish coding tasks 55% faster, and 81% agree that productivity is their biggest benefit. Even if you’ve given AI a try in the past, the technologies are changing weekly with new models, beating the best developers in coding competitions. This new generation of models can understand the context of your entire code base, debugging, commenting, and refactoring code for you. They can help you as an AI pair programmer, and eliminate the need to look up solutions online.

What is the Vibe Coding?

Karpathy describes vibe coding as “Giving into vibes, embrace exponentials, and forget that code even exists” At its core vibe coding means working with AI coding assistant and adopting an “accept all” philosophy- assuming the AI will write and fix the software you’re creating with minimal human intervention.

Unlike traditional programming approaches that require developers to craft each line of code, vibe coding encourages developers to:

Focus on high-level ideas and concepts.
Let AI generate the implementation details.
Accept AI suggestions with minimal review or changes.
Use prompt engineering rather than manual coding.
Iterate through AI assistance rather than manual debugging.
This represents a fundamental shift in how we think about the developer’s role-from code writer to code director.

Setup Cursor for Vibe Coding

Cursor AI is an AI-powered code editor designed to enhance the coding experience by integrating AI to assist with various tasks, including code completion, code generation, and codebase understanding. It aims to streamline the coding process and improve productivity. You can download it from here: https://www.cursor.com/downloads

Once you download a cursor code editor you need to setup it up. First you need to setup your keybinding, prompting language and other couple of settings.

Cursor functions more effectively when you grant access to the full code. This allows you to choose how to manage your data. You can either opt for a privacy mode or share your data with Cursor. Within the Cursor settings, you can establish rules for the AI and select the model you wish to use.

If you have API keys for LLM models, you can add them to Cursor and access premium features. However, this option is more expensive than purchasing a pro version of Cursor.

Start Vibe Coding

I found that we need to follow these steps when we vibe coding:

Plan project
Set Guidelines
Write Prompts
Review Output
Iterate

Then I started vibe coding using a cursor. Before that, we needed to plan the application. I’m going to implement a ToDo application that contains an Express JS backend and a React frontend. For that, I used this command first:

Create a full-stack ToDo application using React for the frontend and 
Node.js with Express for the backend. Set up two folders: /client for 
frontend and /server for backend. Use TypeScript in both. 
Include an initial README in root with setup instructions.

In /client folder, create a React app using TypeScript and TailwindCSS. 
Build a simple UI for a ToDo app with the following features:
- Input to add a task
- List to display tasks
- Checkbox to mark complete
- Delete button to remove task
Use functional components and hooks. Maintain tasks using local state.


In /server folder, build a Node.js backend using Express and TypeScript. 
Implement RESTful API endpoints for managing todos:
- GET /todos
- POST /todos
- PUT /todos/:id
- DELETE /todos/:id
Use an in-memory array to store todos. Add basic error handling and 
CORS support.

Then cursor started to create folders and necessary files for the application.

I accepted all the suggestions commands and code changes that Cursor has given to me.

Then I gave a prompt to integrate frontend with backend.

Update the frontend in /client to consume the backend API 
from /server. Replace local state with API calls using axios:
- GET to load todos
- POST to create new todo
- PUT to toggle complete
- DELETE to remove todo
Ensure proper async/await and error handling.

Update the frontend in /client to consume the backend API 
from /server. Replace local state with API calls using axios:
- GET to load todos
- POST to create new todo
- PUT to toggle complete
- DELETE to remove todo
Ensure proper async/await and error handling.

Then Cursor created me a Todo application. But it had some issues. I gave that as prompt and asked to fix. It fixed issues and finally created a ToDo application. Then I asked Cursor to write unit testing for that application using this prompt.

Add basic test coverage:
- For backend: use Jest and Supertest to test API endpoints
- For frontend: use React Testing Library to test rendering and 
user interactions
Include at least 1 test per core functionality.

I provided prompts to prepare it for production.

Prepare the app for deployment:
- Add production build scripts
- Serve React frontend using Express in production
- Add environment variable support (.env)
- Provide instructions to deploy to Vercel (frontend) and Render 
or Railway (backend)

I have noticed that the cursor keeps checkpoints after each prompt. If our prompts go wrong or the application doesn’t work after a new modification, we can simply restore to that checkpoint.

Then I ran the both backend and frontend applications. It worked well. But there were some css issues. But when it comes to functionality, it works really well. Claude 3.7 sonnet performed better than other LLM models.

This is the final application that I have created.

You can enhance the UI by suggesting colors and others alignments. The best part about this application? I didn’t write a single line of code myself. Everything — from installations to commands — was generated by Cursor AI. I didn’t even touch the codebase; I just accepted all the suggestions the AI provided.

What does the future hold with the rise of AI tools?

This is my 2 cents about it:

AI still developing and it’s not too perfect. So still manual intervention for software development must needed.

In the future, we may see a merger of roles, such as DevOps engineers and software engineers. Companies will likely expect engineers to be proficient in multiple programming languages, creating a demand for T-shaped engineers.

Continuous learning and efficient use of these tools will give individuals a competitive edge in this evolving landscape. A deeper understanding of these technologies will aid in this process.

Happy Coding 🚀!

Deploying a Spring Boot Application on Kubernetes with AWS EKS

Chanuka Dinuwan — Sat, 22 Mar 2025 10:41:02 +0000

In this guide, we will explore how to deploy a Spring Boot application to AWS Elastic Kubernetes Service (EKS). To follow along, you need:

An AWS account
AWS CLI installed and configured
Kubectl (Kubernetes command-line tool)
Docker
eksctl (for creating EKS clusters)

We will follow these steps:

Create a Spring Boot application.
Generate a Dockerfile for the application.
Push the Docker image to AWS Elastic Container Registry (ECR).
Deploy the application in AWS EKS.
Expose the application using a LoadBalancer Service

Create a Spring Boot application

For this guide, I have created a simple Spring Boot application. You can find the source code here: GitHub Repository

Generate a Docker Image from the Spring Boot application

Then, we need to create a Dockerfile for our AWS application. Dockerfile should be like this:

FROM openjdk-17
ADD target/springboot-eks-deployment.jar springboot-eks-deployment.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "springboot-eks-deployment.jar"]

Ensure your pom.xml tag is set springboot-eks-deployment so that the JAR file matches the expected name.

docker build -t springboot-eks .

Push that Dockerfile into AWS ECR

Then, create a repository in ECR.

Then, go inside the repository and click the view push commands button. Then you can see a pop-up like this:

Copy the first command and paste that into your command line.

aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin 135808938067.dkr.ecr.us-east-1.amazonaws.com

Then, tag the image:

docker tag springboot-eks:latest 135808938067.dkr.ecr.us-east-1.amazonaws.com/springboot-eks:latest

Then, push the image:

docker push 135808938067.dkr.ecr.us-east-1.amazonaws.com/springboot-eks:latest

Once pushed, keep the image URI for deployment.

Pull the Image and Deploy on EKS

Let’s create an EKS cluster.

eksctl create cluster --name eks-cluster-springboot --version 1.28 --nodes=1 --node-type=t2.small --region us-east-2

Suppose you can’t find any command like this. Please run the following commands to install it.

brew tap weaveworks/tap brew install weaveworks/tap/eksctl
Once you enter the command, the CLI looks like:

It takes 15–20 minutes to finish the cluster creation.

Let’s add kubeconfig to our machine CLI.
aws eks --region us-east-2 update-kubeconfig --name eks-cluster-springboot

Then, create a configuration file for Kubernetes.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp
spec:
  replicas: 3
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
        - name: myapp
          image: <your docker image url>
          ports:
            - containerPort: 8080

---
apiVersion: v1
kind: Service
metadata:
  name: myapp-service
spec:
  selector:
    app: myapp
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8080
  type: LoadBalancer

Apply it:

kubectl apply -f k8s.yaml

Validate using:

kubectl get svc

You can see my-app deployment created in EKS.

You can see after get svc command URL like this:

a6a6cb0416fc14d5faa0dad2735bbc7a-869757534.us-east-2.elb.amazonaws.com

Visit this URL in your browser to access the Spring Boot application.

Cleanup: Delete the EKS Cluster

After you try this out by yourself, it’s better to delete the Kubernetes Cluster. EKS is expensive. You can use a command similar to the below to delete your EKS cluster.

eksctl delete cluster --name eks-cluster-springboot --region us-east-2

Conclusion

In this guide, we successfully deployed a Spring Boot application on AWS EKS. We covered:

✅ Creating a Spring Boot application ✅ Containerizing it with Docker ✅ Pushing the image to AWS ECR ✅ Deploying it in an EKS cluster ✅ Exposing it with a LoadBalancer service

Now you have a fully functional Spring Boot application running on Kubernetes! Happy Coding!🚀

Implementing Feature Flag Management in Your Spring Boot Application Using API Calls and UI with Togglz

Chanuka Dinuwan — Sun, 29 Dec 2024 15:57:01 +0000

In modern software development, the ability to control features in a live application without deploying new code is crucial. This capability, known as feature flag management, allows teams to turn features on or off in real-time, enabling continuous delivery, A/B testing, and canary releases. It also plays a significant role in reducing risks associated with new deployments by controlling the exposure of new features to users.

In this article, we’ll walk through the process of implementing feature flag management in a Spring Boot application using Togglz. We’ll explore how to configure Togglz, define feature flags, and control their behaviour within your application.

1. Setting Up Togglz in Your Spring Boot Application

To get started with Togglz, you’ll need to add the necessary dependencies to your Spring Boot project. Open your build.gradle or pom.xml file and add the following dependencies:

implementation 'org.togglz:togglz-spring-boot-starter:3.1.2'
implementation 'org.togglz:togglz-console:3.3.3'

These dependencies include the core Togglz functionality and an optional web-based console for managing your feature flags.

2. Configuring Togglz

Next, you’ll need to configure Togglz in your Spring Boot application. This involves setting up a FeatureManager bean that Togglz uses to manage your feature flags.

Here’s how you can do it:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.togglz.core.manager.FeatureManager;
import org.togglz.core.manager.FeatureManagerBuilder;
import org.togglz.core.repository.jdbc.JdbcStateRepository;
import org.togglz.core.user.NoOpUserProvider;

import javax.sql.DataSource;

@Configuration
public class TogglzConfiguration {

    private final DataSource dataSource;

    @Autowired
    public TogglzConfiguration(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    @Bean
    public FeatureManager featureManager() {
        return new FeatureManagerBuilder()
                .featureEnum(ProductCheckFeature.class)
                .stateRepository(new JdbcStateRepository(dataSource))
                .userProvider(new NoOpUserProvider())
                .build();
    }
}

Explanation:

DataSource: The DataSource is injected to be used by the JdbcStateRepository. This allows Togglz to persist feature flag states in a database.
FeatureManager: The FeatureManager is built using a FeatureManagerBuilder. We specify the enum that defines the features (ProductCheckFeature.class), use a JdbcStateRepository for storing feature states, and a NoOpUserProvider since we’re not associating users with features in this example.

3. Defining Feature Flags with Enums

Togglz uses enums to define feature flags. Each constant in the enum represents a feature that can be toggled on or off. Here’s an example:

import org.togglz.core.Feature;
import org.togglz.core.annotation.Label;

public enum ProductCheckFeature implements Feature {

    @Label("product-check")
    PRODUCT_CHECK,

}

Explanation:

Label: The @Label annotation provides a human-readable name for the feature. This name will be displayed in the Togglz console if you decide to use it.

4. Using Feature Flags in Your Application

Once the feature flags are defined and the configuration is in place, you can start using them in your application. Here’s an example of how to check if a feature is active before executing certain code:

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.togglz.core.manager.FeatureManager;
import reactor.core.publisher.Mono;

import javax.servlet.http.HttpServletRequest;

@RestController
@RequestMapping("/api/products")
public class ProductController {

    private final FeatureManager featureManager;
    private final ProductService productService;

    public ProductController(FeatureManager featureManager, ProductService productService) {
        this.featureManager = featureManager;
        this.productService = productService;
    }

    @GetMapping("/check")
    public Mono<ResponseEntity<?>> checkProduct(@RequestParam String isbn, HttpServletRequest httpServletRequest) {
        if (featureManager.isActive(ProductCheckFeature.PRODUCT_CHECK)) {
            return productService
                    .productCheck(isbn, JwtUtils.getUserJwt(httpServletRequest), Boolean.FALSE)
                    .flatMap(response -> Mono.just(ResponseEntity.ok(response)));
        } 
        return Mono.just(ResponseEntity.status(HttpStatus.NOT_IMPLEMENTED).body("Feature is disabled"));
    }
}

Explanation:

FeatureManager: The FeatureManager is injected into the controller and used to check if the PRODUCT_CHECK feature is active.
Conditional Logic: If the feature is active, the product check operation is performed; otherwise, a “Feature is disabled” message is returned.

5. Managing Feature Flags via Togglz Console

The Togglz console is a powerful tool that allows you to manage your feature flags through a web interface. To enable the Togglz console, simply add the following property to your application.properties or application.yml file:

togglz.console.enabled=true

You can access the console by navigating to /togglz-console in your web browser. The console provides an easy-to-use interface for turning features on or off, changing their strategies, and viewing their current state.

Conclusion

Implementing feature flag management with Togglz in your Spring Boot application is a straightforward process that offers powerful control over your features. By following the steps outlined in this article, you can easily configure, define, and manage feature flags, allowing you to release new features with confidence and flexibility.

Whether you’re rolling out a new feature gradually, conducting A/B testing, or simply want to minimize deployment risks, Togglz provides a robust solution that integrates seamlessly into your Spring Boot application.

Happy Coding! 🚀