Spring Mvc To Boot Migrator

Spring MVC to Spring Boot Migrator

Overview

This skill automatically migrates Spring MVC applications to Spring Boot, transforming build configuration, annotations, XML configuration, controllers, and tests while preserving existing functionality. It handles Maven and Gradle projects, creates incremental git commits, and generates detailed migration summaries.

Quick Start

Basic Usage

# Navigate to your Spring MVC project
cd /path/to/spring-mvc-project

# Run migration (auto-detects Maven or Gradle)
python scripts/migrate.py .

# Or specify build tool explicitly
python scripts/migrate.py . --build-tool maven

The migration process will:

1. Create a migration branch
2. Analyze your codebase
3. Update build configuration
4. Migrate annotations
5. Convert configuration files
6. Update tests
7. Generate a summary report

Example Migration

# Migrate Spring MVC project
python scripts/migrate.py /path/to/project

# Output:
# ✓ Detected build tool: maven
# ✓ Detected Spring version: 5.3.20
# ✓ Created migration branch: migrate-spring-mvc-to-boot
# ✓ Analyzing codebase...
# ✓ Found 8 controllers
# ✓ Found 12 services
# ✓ Found 15 test files
# ✓ Migrating build configuration...
# ✓ Migrating annotations...
# ✓ Migrating configuration...
# ✓ Migrating tests...
# ✓ Migration completed successfully!

Supported Migration Paths

Spring MVC → Spring Boot

What gets migrated:

1. Build Configuration

   • Maven: Add Spring Boot parent, update dependencies, add Spring Boot plugin
   • Gradle: Add Spring Boot plugin, update dependencies

2. Annotations

   • @Controller + @ResponseBody → @RestController
   • @RequestMapping(method = RequestMethod.GET) → @GetMapping
   • Similar for @PostMapping, @PutMapping, @DeleteMapping
   • Update imports from javax.* to jakarta.*

3. Configuration

   • XML configuration → Java configuration + application.properties
   • web.xml → Spring Boot auto-configuration
   • Create Spring Boot main application class

4. Tests

   • JUnit 4 → JUnit 5
   • @RunWith(SpringRunner.class) → @SpringBootTest
   • Manual MockMvc setup → @AutoConfigureMockMvc

Example transformation:

Before (Spring MVC):

@Controller
@RequestMapping("/users")
public class UserController {

    @RequestMapping(method = RequestMethod.GET)
    @ResponseBody
    public List<User> getUsers() {
        return userService.findAll();
    }
}

After (Spring Boot):

@RestController
@RequestMapping("/users")
public class UserController {

    @GetMapping
    public List<User> getUsers() {
        return userService.findAll();
    }
}

Migration Process

Phase 1: Preparation

The migration tool automatically:

• Validates the repository is a git repo
• Detects build tool (Maven or Gradle)
• Detects current Spring version
• Creates a migration branch
• Analyzes codebase structure

Phase 2: Build Configuration Migration

Maven projects:

• Adds Spring Boot parent POM
• Replaces individual Spring dependencies with Spring Boot starters
• Adds Spring Boot Maven plugin
• Updates dependency versions

Gradle projects:

• Adds Spring Boot plugin
• Adds dependency management plugin
• Replaces dependencies with Spring Boot starters
• Updates build configuration

Phase 3: Annotation Migration

Updates Java annotations:

• Controller annotations (@RestController)
• Request mapping annotations (@GetMapping, @PostMapping, etc.)
• Import statements (javax.* → jakarta.*)
• Creates Spring Boot main application class with @SpringBootApplication

Phase 4: Configuration Migration

Converts configuration:

• XML configuration → Java configuration classes
• web.xml → Spring Boot auto-configuration
• Creates application.properties with common settings
• Identifies manual conversion needs for complex XML configs

Phase 5: Test Migration

Updates test files:

• JUnit 4 → JUnit 5 annotations
• Test runner annotations
• MockMvc setup
• Test context configuration
• Assertion methods

Phase 6: Summary Generation

Creates comprehensive report:

• Total changes made
• Files modified by category
• Migration plan executed
• Next steps for manual review
• Saved as MIGRATION_SUMMARY.json

Using the Migration Scripts

Main Migration Script

python scripts/migrate.py <repo_path> [--build-tool <maven|gradle|auto>]

# Options:
#   repo_path: Path to the Spring MVC repository
#   --build-tool: Build tool (default: auto-detect)

Individual Migration Modules

You can also run individual migration steps:

from migrate_build import BuildMigrator
from migrate_annotations import AnnotationMigrator
from migrate_config import ConfigMigrator
from migrate_tests import TestMigrator

# Run specific migration
migrator = AnnotationMigrator(repo_path)
migrator.migrate()

Post-Migration Steps

After migration completes:

1. Review the changes

   git log --oneline
   git diff main..migrate-spring-mvc-to-boot

2. Build the project

   # Maven
   mvn clean package
   
   # Gradle
   gradle clean build

3. Run the application

   # Maven
   mvn spring-boot:run
   
   # Gradle
   gradle bootRun
   
   # Or run JAR directly
   java -jar target/myapp.jar

4. Run tests

   # Maven
   mvn test
   
   # Gradle
   gradle test

5. Manual review needed for:

   • Complex XML configuration (convert to Java config)
   • Custom servlet filters
   • Advanced security configuration
   • Third-party integrations
   • Custom view resolvers

6. Test endpoints

   curl http://localhost:8080/users

7. Merge when ready

   git checkout main
   git merge migrate-spring-mvc-to-boot