AWS Builder Center
Explorando o AWS Transform: de Java 8 para 21 em menos de 10 minutos

Explorando o AWS Transform: de Java 8 para 21 em menos de 10 minutos

O que acontece quando você deixa um agente de IA modernizar uma aplicação Java 8 do jeito que ela aparece no mundo real: javax.*, SpringFox, JUnit 4 e Spring Boot 2.7. Testei o AWS Transform Custom na prática e documentei cada mudança.

O Java 8 ainda roda em milhares de aplicações em produção pelo mundo. A distância entre as aplicações legadas e o ecossistema moderno só aumenta, e junto com ela crescem o risco de vulnerabilidades de segurança, a perda de ganhos de performance e o acúmulo de dívida técnica.
Eu quis explorar o AWS Transform Custom (ATX) na prática para ver se a modernização automatizada realmente entrega o que promete em um projeto (quase) real. Foi o que aconteceu quando apontei a ferramenta para uma aplicação Java 8 em Spring Boot e apertei enter.

O experimento

Construí uma API REST propositalmente carregada com o tipo de dívida técnica que a gente encontra em projetos Java 8 do mundo real: um Task Manager rodando Spring Boot 2.7 com todos os padrões legados que tornam um upgrade doloroso:
  • imports  javax.*  (namespace anterior ao Jakarta)
  • SpringFox Swagger 2.x (descontinuado)
  • JUnit 4 com  @RunWith(SpringRunner.class) 
  •  new Date()  misturado com  java.time.LocalDateTime 
  • Apache Commons Lang 3.9 com métodos descontinuados
  • Jackson 2.13, já antigo
Aquele tipo de projeto que todo desenvolvedor sabe que precisa ser atualizado, mas ninguém quer encarar na mão.

A aplicação original (Java 8)

Uma API REST comum, com operações CRUD completas para tarefas.
O  pom.xml  traz as dependências que definem a dívida técnica:
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.7.18</version>
</parent>
<properties>
<java.version>1.8</java.version>
</properties>
<dependencies>
<!-- SpringFox Swagger - deprecated -->
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-boot-starter</artifactId>
<version>3.0.0</version>
</dependency>
<!-- JUnit 4 -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13.2</version>
<scope>test</scope>
</dependency>
</dependencies>

O  Task.java  é a entidade que usa  javax.*  e o  Date  descontinuado:
import javax.persistence.*;
import javax.validation.constraints.NotBlank;
import java.util.Date;

@Entity
public class Task {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@NotBlank(message = "Title is required")
private String title;
@Deprecated
@Transient
private Date legacyCreatedDate;
@PrePersist
protected void onCreate() {
createdAt = LocalDateTime.now();
legacyCreatedDate = new Date(); // deprecated mixing
}
}

O  TaskController.java  usa as anotações do SpringFox:
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import javax.validation.Valid;

@RestController
@RequestMapping("/tasks")
@Api(tags = "Task Management", description = "CRUD operations for tasks")
public class TaskController {
@GetMapping
@ApiOperation(value = "Get all tasks", notes = "Returns a list of all tasks")
public ResponseEntity<List<TaskResponse>> getAllTasks(
@ApiParam(value = "Filter by task status")
@RequestParam(required = false) TaskStatus status) {
// ...
}
}

O  TaskServiceTest.java  traz os testes em JUnit 4:
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.junit.MockitoJUnitRunner;
import static org.junit.Assert.*;

@RunWith(MockitoJUnitRunner.class)
public class TaskServiceTest {
@Before
public void setUp() { /* ... */ }
@Test(expected = TaskNotFoundException.class)
public void testUpdateTask_NotFound() {
taskService.updateTask(99L, request);
}
}


Rodando o Transform

A configuração foi surpreendentemente simples. Criei um  config.json :
{
"codeRepositoryPath": "./",
"transformationName": "AWS/java-version-upgrade",
"buildCommand": "mvn clean package -DskipTests",
"validationCommands": "mvn clean package",
"additionalPlanContext": "Java 8 to 21 transformation. Migrate javax.* to jakarta.*, upgrade Spring Boot 2.7 to 3.x, update JUnit 4 to JUnit 5, replace SpringFox with SpringDoc OpenAPI, modernize deprecated APIs."
}

Depois rodei um único comando no terminal do Kiro:
atx custom def exec -t --configuration file://config.json

O agente analisou o código, montou um plano de transformação e executou as mudanças com commits versionados a cada etapa.

O resultado: diffs reais da branch do transform

1. javax.* vira jakarta.*

- import javax.persistence.*;
- import javax.validation.constraints.NotBlank;
- import javax.validation.constraints.Size;
- import java.util.Date;
+ import jakarta.persistence.*;
+ import jakarta.validation.constraints.NotBlank;
+ import jakarta.validation.constraints.Size;
+ import java.time.Instant;


2. Spring Boot 2.7.18 vira 3.2.12 com Java 21

<parent>
<artifactId>spring-boot-starter-parent</artifactId>
- <version>2.7.18</version>
+ <version>3.2.12</version>
</parent>

<properties>
- <java.version>1.8</java.version>
- <maven.compiler.source>1.8</maven.compiler.source>
- <maven.compiler.target>1.8</maven.compiler.target>
+ <java.version>21</java.version>
+ <maven.compiler.source>21</maven.compiler.source>
+ <maven.compiler.target>21</maven.compiler.target>
</properties>


3. SpringFox vira SpringDoc OpenAPI

- import io.swagger.annotations.Api;
- import io.swagger.annotations.ApiOperation;
- import io.swagger.annotations.ApiParam;
+ import io.swagger.v3.oas.annotations.Operation;
+ import io.swagger.v3.oas.annotations.Parameter;
+ import io.swagger.v3.oas.annotations.tags.Tag;

- @Api(tags = "Task Management", description = "CRUD operations for tasks")
+ @Tag(name = "Task Management", description = "CRUD operations for tasks")
- @ApiOperation(value = "Get all tasks", notes = "Returns a list of all tasks")
+ @Operation(summary = "Get all tasks", description = "Returns a list of all tasks")
- @ApiParam(value = "Filter by task status")
+ @Parameter(description = "Filter by task status")

A troca de dependência no  pom.xml :
- <dependency>
- <groupId>io.springfox</groupId>
- <artifactId>springfox-boot-starter</artifactId>
- <version>3.0.0</version>
- </dependency>
+ <dependency>
+ <groupId>org.springdoc</groupId>
+ <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
+ <version>2.3.0</version>
+ </dependency>


4. JUnit 4 vira JUnit 5

- import org.junit.Before;
- import org.junit.Test;
- import org.junit.runner.RunWith;
- import org.mockito.junit.MockitoJUnitRunner;
- import static org.junit.Assert.*;
+ import org.junit.jupiter.api.BeforeEach;
+ import org.junit.jupiter.api.Test;
+ import org.junit.jupiter.api.extension.ExtendWith;
+ import org.mockito.junit.jupiter.MockitoExtension;
+ import static org.junit.jupiter.api.Assertions.*;

- @RunWith(MockitoJUnitRunner.class)
+ @ExtendWith(MockitoExtension.class)
public class TaskServiceTest {
- @Before
+ @BeforeEach
public void setUp() { /* ... */ }
- @Test(expected = TaskNotFoundException.class)
- public void testUpdateTask_NotFound() {
- taskService.updateTask(99L, request);
- }
+ @Test
+ public void testUpdateTask_NotFound() {
+ assertThrows(TaskNotFoundException.class,
+ () -> taskService.updateTask(99L, request));
+ }
}

A dependência do JUnit 4 foi removida por completo do  pom.xml , já que o  spring-boot-starter-test  do Spring Boot 3.x já traz o JUnit 5 embutido.

5. java.util.Date vira java.time.Instant

- import java.util.Date;
@Deprecated
@Transient
- private Date legacyCreatedDate;
+ private Instant legacyCreatedDate;
@PrePersist
protected void onCreate() {
createdAt = LocalDateTime.now();
updatedAt = LocalDateTime.now();
- legacyCreatedDate = new Date();
+ legacyCreatedDate = Instant.now();
}


6. Versões de dependências atualizadas em toda a base

  • Spring Boot: 2.7.18 para 3.2.12
  • Lombok: 1.18.36 para 1.18.46
  • Apache Commons Lang: 3.9 para 3.14.0
  • Jackson: 2.13.5 para 2.15.2
  • Maven Compiler Plugin: 3.11.0 para 3.13.0
  • Maven Surefire Plugin: 2.22.2 para 3.2.5

Os números que importam

  • Linhas de código: cerca de 1.200
  • Tempo: cerca de 8 minutos
  • Custo: menos de US$ 0,50
  • Build: passou de primeira ✅
Compare isso com fazer tudo na mão. Eu precisaria de pelo menos 2 a 3 dias para aplicar essas mudanças com confiança, testar cada uma, resolver conflitos de dependência e garantir que nada quebrou.

O que eu aprendi

  1. Quanto mais contexto você dá no  additionalPlanContext , melhor o resultado. Seja específico sobre o que quer transformar.
  1. No upgrade de Spring Boot 2 para 3, o Transform entendeu sozinho que precisava migrar para o Jakarta ao mesmo tempo. Ele tratou a migração de SpringFox para SpringDoc dentro da mesma passada.
  1. A US$ 0,035 por minuto de agente, até um projeto de 17 mil linhas sai por volta de US$ 2,52. Pelo que entrega, é praticamente de graça.
  1. Desde abril de 2026, o ATX roda direto no terminal integrado. Sem configuração extra.
  1. Cada etapa da transformação gera um commit separado, então dá para revisar as mudanças aos poucos e reverter se precisar.

Para quem isso serve

  • Times rodando Java 8 ou 11 que precisam chegar ao 17 ou 21
  • Times de plataforma com dívida técnica se acumulando
  • Líderes de engenharia que querem reduzir a dívida técnica

Experimente você mesmo

  1. Instale o  Kiro 
  1. Abra seu projeto Java 8 no terminal
  1. Rode o comando e peça o upgrade
  1. Pegue um café enquanto ele trabalha
O código original e o resultado transformado estão no meu GitHub:
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article