Skip to content

Latest commit

 

History

History
100 lines (64 loc) · 4.42 KB

aot.adoc

File metadata and controls

100 lines (64 loc) · 4.42 KB
Raw

Ahead-of-Time Processing

Spring AOT is a process that analyzes your application at build-time and generate an optimized version of it. It is a mandatory step to run a Spring ApplicationContext in a native image.

Note
 For an overview of GraalVM Native Images support in Spring Boot, check the reference documentation.

The Spring Boot Maven plugin offers goals that can be used to perform AOT processing on both application and test code.

Processing Applications

To configure your application to use this feature, add an execution for the process-aot goal, as shown in the following example:

link:example$aot/pom.xml[role=include]

As the BeanFactory is fully prepared at build-time, conditions are also evaluated. This has an important difference compared to what a regular Spring Boot application does at runtime. For instance, if you want to opt-in or opt-out for certain features, you need to configure the environment used at build time to do so. The process-aot goal shares a number of properties with the run goal for that reason.

Using the Native Profile

If you use spring-boot-starter-parent as the parent of your project, a native profile can be used to streamline the steps required to build a native image.

The native profile configures the following:

  • Execution of process-aot when the Spring Boot Maven Plugin is applied on a project.

  • Suitable settings so that build-image generates a native image.

  • Sensible defaults for the {url-native-build-tools-docs-maven-plugin}[Native Build Tools Maven Plugin], in particular:

    • Making sure the plugin uses the raw classpath, and not the main jar file as it does not understand our repackaged jar format.

    • Validate that a suitable GraalVM version is available.

    • Download third-party reachability metadata.

To benefit from the native profile, a module that represents an application should define two plugins, as shown in the following example:

link:example$aot-native/pom.xml[role=include]

A single project can trigger the generation of a native image on the command-line using either Cloud Native Buildpacks or Native Image Build Tools.

To use the native profile with a multi-modules project, you can create a customization of the native profile so that it invokes your preferred technique.

To bind Cloud Native Buildpacks during the package phase, add the following to the root POM of your multi-modules project:

link:example$aot-native-profile-buildpacks/pom.xml[role=include]

The example below does the same for Native Build Tools:

link:example$aot-native-profile-nbt/pom.xml[role=include]

Once the above is in place, you can build your multi-modules project and generate a native image in the relevant sub-modules, as shown in the following example:

$ mvn package -Pnative
Note
 A "relevant" sub-module is a module that represents a Spring Boot application. Such module must define the Native Build Tools and Spring Boot plugins as described above.

Processing Tests

The AOT engine can be applied to JUnit 5 tests that use Spring’s Test Context Framework. Suitable tests are processed by the AOT engine in order to generate ApplicationContextInitializer code.

To configure your application to use this feature, add an execution for the process-test-aot goal, as shown in the following example:

link:example$aot-test/pom.xml[role=include]
Tip
 If you are using spring-boot-starter-parent, this execution is automatically configured if you enable the nativeTest profile.

As with application AOT processing, the BeanFactory is fully prepared at build-time.