Integrating Dapr with Spring Applications Seamlessly

In the modern world of microservices, developers often face challenges integrating different services while maintaining the simplicity and scalability of their applications. Enter Dapr (Distributed Application Runtime) — an open-source, portable runtime that simplifies the development of cloud-native applications.

In this blog, I’ll walk you through a practical way to integrate Dapr within your Spring Boot applications without the need to run Dapr commands separately, keeping your setup efficient and developer-friendly.

Why Dapr?

Dapr provides building blocks for microservices, such as state management, service invocation, pub/sub messaging, and observability. It eliminates boilerplate code and allows you to focus on business logic while enabling a polyglot microservices ecosystem.

If you’re using Spring Boot, you can harness Dapr’s power to achieve seamless integration for distributed application communication, ensuring scalability and resilience.

Key Challenges in Traditional Dapr Integration

Typically, using Dapr involves running a dapr run command alongside your service to start the runtime environment. However, this extra step can complicate development workflows. Developers often wish for Dapr to run within the application lifecycle, reducing dependency on external commands.

Setting Up Dapr with Spring Boot

Step 1: Add Dependencies

First, add the required Maven dependencies for Dapr and Spring Boot. If you’re working with Java 17+ and Spring Boot 3, you can use the following dependencies:

<dependency>
    <groupId>io.dapr</groupId>
    <artifactId>dapr-sdk</artifactId>
    <version>1.13.0</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

These libraries allow you to interact with Dapr components via SDKs instead of shell commands.

Step 2: Configure Embedded Dapr Runtime

To ensure Dapr starts automatically when your application launches, you can use an embedded runtime within the application. Here’s an example of a Spring Boot configuration class:

import io.dapr.client.DaprClient;
import io.dapr.client.DaprClientBuilder;
import io.dapr.runner.DaprApplicationRunner;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class DaprConfiguration {

    @Bean
    public DaprClient daprClient() {
        return new DaprClientBuilder().build();
    }

    @Bean
    public DaprApplicationRunner daprApplicationRunner() {
        return new DaprApplicationRunner("app-id", "localhost:3500");
    }
}

Here:

• DaprClient provides APIs for state management, pub/sub, and service invocation.
• DaprApplicationRunner ensures Dapr runs with your application.

Step 3: Leverage Dapr Building Blocks

With the above setup, you can now use Dapr’s APIs directly in your services. Below is an example of a state management service:

import io.dapr.client.DaprClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/state")
public class StateController {

    @Autowired
    private DaprClient daprClient;

    @PostMapping("/save")
    public String saveState(@RequestBody StateRequest request) {
        daprClient.saveState("statestore", request.getKey(), request.getValue()).block();
        return "State saved!";
    }

    @GetMapping("/get/{key}")
    public String getState(@PathVariable String key) {
        return daprClient.getState("statestore", key, String.class).block();
    }
}

class StateRequest {
    private String key;
    private String value;

    // Getters and Setters
}

In this example:

• The saveState API stores a key-value pair in the configured state store.
• The getState API retrieves data for a given key.

Benefits of Embedded Dapr Integration

1. Simplified Workflows: Developers no longer need to start Dapr separately. It runs seamlessly as part of the Spring Boot lifecycle.
2. Better Deployment: The application remains self-contained, making CI/CD pipelines straightforward.
3. Enhanced Productivity: Faster development cycles with less friction between service execution and runtime management.

Testing Your Application

Run your Spring Boot application as you normally would. You should see Dapr logs integrated into your application logs. Use REST tools like Postman or curl to interact with the APIs.

For example:

curl -X POST http://localhost:8080/state/save -H "Content-Type: application/json" \
-d '{"key": "test-key", "value": "test-value"}'
curl http://localhost:8080/state/get/test-key

Conclusion

Integrating Dapr with Spring Boot can greatly simplify your microservices architecture. By embedding the Dapr runtime into your application lifecycle, you eliminate unnecessary steps and streamline development.

This approach ensures you get the best of both worlds — Spring Boot’s powerful ecosystem combined with Dapr’s lightweight and flexible runtime for distributed systems. Give it a try in your next project and see how it transforms your development experience!