Upgrade Java 8 to 21 and Reduce Tech Debt With Amazon Q Developer - Transform.

Modernizing Java applications has always been a challenge. As a Java developer, I’ve faced the difficulties of upgrading legacy code—managing technical debt, dealing with dependency issues, and investing significant time to ensure a smooth transition. Moving from Java 8 to a newer version often felt like more trouble than it was worth.

Now, Amazon Q Developer makes this process much easier. This AI-powered tool automates the transformation of Java 8 applications to Java 21, significantly reducing the time and effort required. What used to take weeks can now be done quickly, allowing developers to focus on building new features instead of fixing old code.

Overview of a solution

Amazon Q Developer: Transform automates common language upgrade tasks such as code updates, unit testing, and deployment readiness verification—starting with Java.

By leveraging Amazon Q Developer: Transform, teams can improve security, enhance performance, and reduce technical debt. In just a few steps, applications can be upgraded to the latest supported Java versions, benefiting from improved efficiency while eliminating vulnerabilities found in outdated versions.

In this post, I’ll explore how Amazon Q Developer simplifies upgrades and why it’s a valuable tool for Java teams. We will accelerate Java application upgrades from Java 8 to Java 21.

Prerequisites

Before you start, you need to ensure that you have:

• Install Amazon Q Developer in Visual Studio Code.
• Install Java 8 JDK and Java 21 JDK. I used Amazon Corretto 8 and Amazon Corretto 21.

Walkthrough

Preparing the Java 8 application

The sample Java 8 EE application provides Create, Read, Update, and Delete (CRUD) operations. It stores data in a PostgreSQL relational database and publishes events for each action.

git clone https://github.com/aws-samples/java-on-aws
cd java-on-aws/apps/unicorn-store-javax/
code .

Using Amazon Q Developer to update the Java 8 application to Java 21

Make sure that you set Amazon Q Developer up using steps in Install Amazon Q Developer

1. Open Amazon Q Developer console and type /transform. Previously I switched to the application folder code . to define which application I want to transform.

2. Answer questions of Amazon Q Developer:

• Choose the target code version: 21
• Choose to skip unit tests: Run unit tests
• Choose how to receive proposed changes: One diff
• Enter the path to JDK 8. Amazon Q Developer will offer a command which helps you to find the path to JDK 8.

Amazon Q Developer Transform will build the Java application locally first before uploading it to the secure transform environment.

3. Start the transformation process and monitor its progress.

4. The transformation process for this Java application takes approximately 5-10 minutes to complete. Once finished, you can review the proposed changes.

Amazon Q Developer: Transform automatically updates the Java version and its dependencies.

Amazon Q Developer: Transform updates javax imports to jakarta.

Amazon Q Developer: Transform is able to handle updates in UI files.

Amazon Q Developer: Transform can detect and replace deprecated code with modern equivalents.

Testing the Java 21 application with Java 21 JDK

I use Docker Compose to test the Java application. For the Java 8 application version I used the WildFly 26.X application server, because Java 8 is no longer supported starting with the WildFly 27 series. For Java 21 application version I will use the recent version of WildFly 35.X.

1. Update Dockerfile to use container images that support Java 21 (lines 1 and 7):

code ./Dockerfile

FROM public.ecr.aws/docker/library/maven:3-amazoncorretto-21-al2023 AS builder

COPY ./pom.xml ./pom.xml
COPY src ./src/
RUN mvn clean package --no-transfer-progress

FROM quay.io/wildfly/wildfly:35.0.0.Final-jdk21 AS runtime
ENV POSTGRESQL_JDBC_DRIVER_VERSION=42.7.3
RUN curl -L "https://repo1.maven.org/maven2/org/postgresql/postgresql/${POSTGRESQL_JDBC_DRIVER_VERSION}/postgresql-${POSTGRESQL_JDBC_DRIVER_VERSION}.jar" -o $JBOSS_HOME/postgresql.jar
RUN printenv > $JBOSS_HOME/env.properties

COPY ./datasource.cli $JBOSS_HOME/datasource.cli
RUN /opt/jboss/wildfly/bin/jboss-cli.sh --echo-command --file="$JBOSS_HOME/datasource.cli" --properties="$JBOSS_HOME/env.properties"
RUN rm /opt/jboss/wildfly/standalone/configuration/standalone_xml_history/current/*
COPY --from=builder target/store-javax.war $JBOSS_HOME/standalone/deployments/store-javax.war

USER 1000:1000
EXPOSE 8080

CMD ["/opt/jboss/wildfly/bin/standalone.sh", "-b", "0.0.0.0", "-bmanagement", "0.0.0.0"]

2. Start the build for a container image:

docker build -t unicorn-store-javax:latest .

3. Start the application using Docker Compose:

docker compose up
docker rm $(docker ps -a | grep "javax" | awk '{print $1}')

4. Open a new terminal window and test the application via curl:

SVC_URL=http://localhost:8080
curl --location $SVC_URL'/api/hello'; echo
curl --location --request POST $SVC_URL'/api/unicorns' --header 'Content-Type: application/json' --data-raw '{
    "name": "'"Something-$(date +%s)"'",
    "age": "20",
    "type": "Animal",
    "size": "Very big"
}' | jq

Welcome to the Unicorn Store!
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100   221  100   120  100   101    185    156 --:--:-- --:--:-- --:--:--   341
{
  "id": "6ebc2827-3168-45cf-b4a9-11a202ee3765",
  "name": "Something-1739713162",
  "age": "20",
  "size": "Very big",
  "type": "Animal"
}

5. Switch back to the initial terminal and stop the application with Ctrl+C.

Cleaning up

1. You may delete created container images and the cloned repository.

Conclusion

In this blog post, I demonstrated how you can transform the Java 8 application to Java 21 using Amazon Q Developer: Transform.

Developers can reduce technical debt and improve performance and security of their Java applications with less effort than before.

Let’s go transform!