Migrating Legacy Spring Applications to Quarkus

Migrating Legacy Spring Applications to Quarkus

February 20, 2025 Quarkus Spring Migration

In this article, I’ll share my experience migrating legacy Spring applications to Quarkus, a modern Java framework designed for cloud-native applications.

Why Migrate to Quarkus?

During my time at PT. Asuransi Jiwa Astra, we successfully migrated several legacy Spring applications to Quarkus. The key benefits we observed were:

1. Faster startup times - From minutes to seconds
2. Lower memory footprint - Significant reduction in heap usage
3. Better developer experience - Live reload and faster builds
4. Cloud-native optimizations - Built for containers and serverless

Migration Strategy

Phase 1: Assessment and Planning

Before starting the migration, we conducted a thorough assessment:

# Analyze existing Spring dependencies
mvn dependency:tree

# Identify custom components and configurations
find . -name "*.xml" -o -name "*.properties" | grep -E "(spring|application)"

Phase 2: Incremental Migration

We didn’t attempt a big-bang migration. Instead, we used a phased approach:

1. Start with new microservices using Quarkus
2. Gradually migrate non-critical components
3. Migrate business-critical services last

Key Migration Challenges

1. Dependency Management

Spring and Quarkus have different dependency ecosystems. Here’s how we handled it:

Before (Spring):

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

After (Quarkus):

<dependency>
    <groupId>io.quarkus</groupId>
    <artifactId>quarkus-resteasy</artifactId>
</dependency>

2. Configuration Changes

Spring Configuration:

@Configuration
public class AppConfig {
    @Bean
    public DataSource dataSource() {
        return new HikariDataSource();
    }
}

Quarkus Equivalent:

@ApplicationScoped
public class DataSourceProducer {
    @Produces
    @ApplicationScoped
    public DataSource dataSource() {
        return new HikariDataSource();
    }
}

3. REST API Migration

Spring Controller:

@RestController
@RequestMapping("/api/users")
public class UserController {
    @GetMapping("/{id}")
    public User getUser(@PathVariable Long id) {
        return userService.findById(id);
    }
}

Quarkus Resource:

@Path("/api/users")
@Produces(MediaType.APPLICATION_JSON)
public class UserResource {
    @GET
    @Path("/{id}")
    public User getUser(@PathParam Long id) {
        return userService.findById(id);
    }
}

Performance Improvements

Startup Time Comparison

Application	Spring Boot	Quarkus	Improvement
User Service	45s	3.2s	93% faster
Order Service	78s	5.1s	93% faster
Integration Service	120s	8.7s	93% faster

Memory Usage

Application	Spring Boot	Quarkus	Reduction
User Service	512MB	128MB	75%
Order Service	768MB	192MB	75%
Integration Service	1GB	256MB	75%

Best Practices Learned

1. Use Quarkus Extensions Wisely

Quarkus provides many extensions. Only include what you need:

<!-- Good: Only what you need -->
<dependency>
    <groupId>io.quarkus</groupId>
    <artifactId>quarkus-resteasy-jackson</artifactId>
</dependency>

<!-- Avoid: Including everything -->
<dependency>
    <groupId>io.quarkus</groupId>
    <artifactId>quarkus-bom</artifactId>
</dependency>

2. Leverage Native Compilation

For maximum performance, use GraalVM native compilation:

# Build native executable
./mvnw package -Pnative

# Results in much faster startup and lower memory

3. Testing Strategy

Update your testing approach for Quarkus:

@QuarkusTest
public class UserResourceTest {
    @Test
    public void testGetUser() {
        given()
            .pathParam("id", 1)
        .when()
            .get("/api/users/{id}")
        .then()
            .statusCode(200)
            .body("name", equalTo("John Doe"));
    }
}

Common Pitfalls to Avoid

1. Don’t Mix Frameworks

Avoid having both Spring and Quarkus dependencies in the same application.

2. Update Build Scripts

Remember to update your Maven/Gradle scripts for Quarkus-specific commands.

3. Monitor Performance

Set up proper monitoring to validate performance improvements.

Conclusion

Migrating from Spring to Quarkus requires careful planning and execution, but the benefits are substantial. Our migration resulted in:

• 93% faster startup times
• 75% reduction in memory usage
• Improved developer productivity
• Better cloud-native capabilities

The key is to approach migration incrementally and thoroughly test each component before moving to the next.

---

This migration was successfully completed for multiple production services at PT. Asuransi Jiwa Astra.