Java / Gradle

Render XML in a Micronaut Controller

Learn how to use Jackson to render XML in a Micronaut Controller

Sergio del Amo
On this guide
In this section

Getting Started

In this guide, we will create a Micronaut application written in Java.

What you will need

To complete this guide, you will need the following:

Solution

We recommend that you follow the instructions in the next sections and create the application step by step. However, you can go right to the completed example.

Writing the Application

Create an application using the Micronaut Command Line Interface or with Micronaut Launch.

mn create-app example.micronaut.micronautguide \
    --features=jackson-databind,jackson-xml \
    --build=gradle \
    --lang=java \
    --test=junit
Note
 If you don’t specify the --build argument, Gradle with the Kotlin DSL is used as the build tool.
If you don’t specify the --lang argument, Java is used as the language.
If you don’t specify the --test argument, JUnit is used for Java and Kotlin, and Spock is used for Groovy.

The previous command creates a Micronaut application with the default package example.micronaut in a directory named micronautguide.

If you use Micronaut Launch, select Micronaut Application as application type and add jackson-databind, and jackson-xml features.

Note
 If you have an existing Micronaut application and want to add the functionality described here, you can view the dependency and configuration changes from the specified features, and apply those changes to your application.

Diff

Setup IntelliJ IDEA to develop Micronaut Applications.

Dependency

In this guide, to render XML, we use Micronaut Jackson XML. Add the following dependency:

build.gradle
implementation("io.micronaut.xml:micronaut-jackson-xml")
Warning
 Micronaut Serialization doesn’t currently support XML.

Book Record

Create a record for the XML model.

java/src/main/java/example/micronaut/Book.java
package example.micronaut;

import io.micronaut.core.annotation.Introspected;
import tools.jackson.dataformat.xml.annotation.JacksonXmlProperty;
import tools.jackson.dataformat.xml.annotation.JacksonXmlRootElement;

@Introspected // 
@JacksonXmlRootElement(localName = "book") // 
public record Book(@JacksonXmlProperty(isAttribute = false) String name,
                   @JacksonXmlProperty(isAttribute = true) String isbn) { // 
}
1 Annotate the class with @Introspected to generate BeanIntrospection metadata at compilation time. This information can be used, for example, to render the POJO as JSON using Jackson without using reflection.
2 @JacksonXmlRootElement annotation defines the name of root element used for the root-level object when serialized.
3 @JacksonXmlProperty annotation provides XML-specific configuration for properties.

Book Controller

Create a controller which returns a Book instance.

java/src/main/java/example/micronaut/BookController.java
package example.micronaut;

import io.micronaut.http.MediaType;
import io.micronaut.http.annotation.Controller;
import io.micronaut.http.annotation.Get;
import io.micronaut.http.annotation.Produces;

@Controller("/book") // 
class BookController {

    @Produces(MediaType.APPLICATION_XML) // 
    @Get // 
    Book index() {
        return new Book("Building Microservices", "1491950358");
    }
}
1 The class is defined as a controller with the @Controller annotation mapped to the path /book.
2 Set the response content-type to XML with the @Produces annotation.
3 The @Get annotation maps the method to an HTTP GET request.

Tests

Create a test which verifies that the controller returns XML.

java/src/test/java/example/micronaut/BookControllerTest.java
package example.micronaut;

import io.micronaut.http.HttpRequest;
import io.micronaut.http.MediaType;
import io.micronaut.http.client.BlockingHttpClient;
import io.micronaut.http.client.HttpClient;
import io.micronaut.http.client.annotation.Client;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
import static org.junit.jupiter.api.Assertions.assertEquals;

@MicronautTest // 
class BookControllerTest {

    @Test
    void testXmlRendered(@Client("/") HttpClient httpClient) { // 
        BlockingHttpClient client = httpClient.toBlocking();
        String xml = assertDoesNotThrow(() ->
                client.retrieve(HttpRequest.GET("/book").accept(MediaType.APPLICATION_XML), String.class));  // 
        assertEquals("""
                <book isbn="1491950358"><name>Building Microservices</name></book>""", xml);
    }
}
1 Annotate the class with @MicronautTest so the Micronaut framework will initialize the application context and the embedded server. More info.
2 Inject the HttpClient bean and point it to the embedded server.
3 Creating HTTP Requests is easy thanks to the Micronaut framework fluid API.

Testing the Application

To run the tests:

./gradlew test

Then open build/reports/tests/test/index.html in a browser to see the results.

Native Tests

The io.micronaut.application Micronaut Gradle Plugin automatically integrates with GraalVM by applying the Gradle plugin for GraalVM Native Image building.

This plugin supports running tests on the JUnit Platform as native images. This means that tests will be compiled and executed as native code.

To execute the tests, execute:

./gradlew nativeTest

Then open build/reports/tests/test/index.html in a browser to see the results.

INFO: A test may be disabled within a GraalVM native image via the @DisabledInNativeImage annotation.

Generate a Micronaut Application Native Executable with GraalVM

We will use GraalVM, an advanced JDK with ahead-of-time Native Image compilation, to generate a native executable of this Micronaut application.

Compiling Micronaut applications ahead of time with GraalVM significantly improves startup time and reduces the memory footprint of JVM-based applications.

Note
 Only Java and Kotlin projects support using GraalVM’s native-image tool. Groovy relies heavily on reflection, which is only partially supported by GraalVM.

GraalVM Installation

The easiest way to install GraalVM on Linux or Mac is to use SDKMan.io.

Java 25
sdk install java 25.0.2-graal

For installation on Windows, or for a manual installation on Linux or Mac, see the GraalVM Getting Started documentation.

The previous command installs Oracle GraalVM, which is free to use in production and free to redistribute, at no cost, under the GraalVM Free Terms and Conditions.

Alternatively, you can use the GraalVM Community Edition:

Java 25
sdk install java 25.0.2-graalce

Native Executable Generation

To generate a native executable using Gradle, run:

./gradlew nativeCompile

The native executable is created in build/native/nativeCompile directory and can be run with build/native/nativeCompile/micronautguide.

It is possible to customize the name of the native executable or pass additional parameters to GraalVM:

build.gradle
graalvmNative {
    binaries {
        main {
            imageName.set('mn-graalvm-application') // 
            buildArgs.add('-Ob') // 
        }
    }
}
1 The native executable name will now be mn-graalvm-application
2 It is possible to pass extra build arguments to native-image. For example, -Ob enables the quick build mode.

You can execute the /book endpoint exposed by the native executable:

curl localhost:8080/book
<book isbn="1491950358"><name>Building Microservices</name></book>

Next Steps

Explore more features with Micronaut Guides.

Learn more about Micronaut Jackson XML.

Help with the Micronaut Framework

The Micronaut Foundation sponsored the creation of this Guide. A variety of consulting and support services are available.

License

Note
 All guides are released with an Apache License 2.0 for the code and a Creative Commons Attribution 4.0 license for the writing and media (images).