Spring Boot 3.3 has brought a variety of improvements, and one of the most exciting features is the full support for Class Data Sharing (CDS). This feature, which builds upon recent advances in Spring Framework 6.1, allows developers to significantly reduce the startup time of their applications and lower memory consumption during runtime.

Class Data Sharing (CDS) has been a hidden gem in the Java ecosystem for years, but it has mostly been underused. In Spring Boot 3.3, CDS receives a major upgrade, allowing developers to fully leverage its capabilities, making it a practical choice for production environments.

CDS vs. GraalVM Native Image: Key Differences

While Spring Boot supports both CDS and GraalVM native images, it is crucial to understand the differences between the two. GraalVM native images are well-known for dramatically reducing startup times, but they come with certain limitations and require more extensive modifications to your development pipeline. CDS, on the other hand, offers a more incremental approach by speeding up your applications without moving away from the JVM you’re already familiar with.

With CDS, you won’t see the same extreme improvements in startup time as with GraalVM native images, but you will still benefit from faster launches while maintaining the flexibility of a JVM-based environment. This makes CDS a more conservative but highly effective optimization, especially for large-scale applications.

The Hidden Power of Class Data Sharing in Java

Class Data Sharing is a JVM-level technology designed to speed up the startup time of Java applications by preloading class data into shared archives. It’s been around for a while, but typically only preloads core JDK classes, leaving your application classes untouched. However, Spring Boot 3.3 introduces new capabilities that allow developers to create a custom CDS archive for their specific applications.

By running a “training” instance of your Spring Boot application, you can build an archive that optimizes the loading of not just JDK classes, but also your application’s classes. This results in noticeable performance improvements, particularly in environments where application startup time is critical.

How to Leverage Spring Boot 3.3 for Optimal CDS Usage

To take full advantage of CDS in Spring Boot 3.3, you need to adhere to certain best practices. For example:

• Use the same JVM that was used to create the CDS archive.
• Ensure that the classpath remains consistent.
• Keep the timestamp of your JAR files intact.

Even small changes in your environment, such as modifying the classpath or adding new JAR files, can prevent the CDS archive from working as intended. Luckily, Spring Boot 3.3 introduces features that simplify the process of creating and using CDS archives.

Self-Extracting Executable JAR in Spring Boot

One of the major hurdles when running Java applications in production has been the inefficiency of running self-contained JAR files using java -jar my-app.jar. Many developers in the Spring community have struggled with this issue, and until recently, there was no built-in solution to this problem.

Spring Boot 3.3 has introduced a new feature: self-extracting executable JAR files. This allows you to run your application more efficiently by extracting the JAR content into an optimized format. All you need is a simple command:

bash

java -Djarmode=tools -jar my-app.jar extract --destination application

Once the JAR is extracted, you can run the application using:

java -jar application/my-app.jar

This approach is not only more efficient but also aligns with the requirements of Class Data Sharing and Project Leyden.Automating CDS with BuildpacksWhile the self-extracting JAR feature is powerful, it still requires manual steps, which can be cumbersome in large-scale environments. To streamline the process, Spring Boot 3.3 also includes support for automating CDS through Buildpacks.Buildpacks offer a seamless way to package your application, automatically creating and using CDS archives during container builds. This eliminates the need for manual setup and ensures that your application benefits from CDS without any additional effort.Here’s how you can enable CDS with Buildpacks using Gradle:

tasks.named("bootBuildImage") {
    environment["BP_JVM_CDS_ENABLED"] = "true"
}

And with Maven:

<plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
    <configuration>
        <image>
            <env>
                <BP_JVM_CDS_ENABLED>true</BP_JVM_CDS_ENABLED>
            </env>
        </image>
    </configuration>
</plugin>

This automation ensures that your application is optimized for CDS every time it is packaged into a container.

Spring AOT Integration for Enhanced Performance

Beyond CDS, Spring Boot 3.3 also integrates support for Spring AOT (Ahead-Of-Time compilation). This can further improve your application’s performance by generating optimized bytecode that reduces the need for runtime reflection and other costly operations.

To enable Spring AOT alongside CDS, you can set the following environment variable:

bash:

BP_SPRING_AOT_ENABLED=true

However, it’s important to note that Spring AOT and CDS cannot be enabled simultaneously during the training run, so careful configuration is needed to avoid potential conflicts.

Future of CDS and Project Leyden

Spring Boot’s support for CDS is not just a temporary enhancement. It lays the groundwork for even more powerful optimizations in the future, particularly with the development of Project Leyden. Project Leyden aims to extend the capabilities of CDS by making applications start even faster and reducing memory usage further.

Preliminary tests show that combining Project Leyden with Spring AOT can result in application startup times that are three to four times faster compared to traditional methods. This makes Project Leyden a promising future direction for Java applications, particularly those running in cloud environments.

Conclusion

Spring Boot 3.3’s new CDS support offers a practical, effective way to speed up Java application startups and reduce memory consumption, making it an attractive option for developers looking to optimize their applications without moving away from traditional JVM environments. With further integration of Buildpacks and the potential of Project Leyden, CDS is poised to play a crucial role in the future of Java performance optimization.

For developers looking to stay on the cutting edge, embracing CDS alongside other Spring Boot 3.3 features like Spring AOT and self-extracting JARs is a great way to ensure their applications are running as efficiently as possible.