Migrate to Micronaut 3 from Micronaut 2

In this guide we'll look at using OpenRewrite to perform an automated migration from Micronaut 2.x to Micronaut 3.x
Example Configuration
Gradle
Maven
build.gradle
1
plugins {
2
    id("org.openrewrite.rewrite") version("5.22.2")
3
}
4
​
5
rewrite {
6
    activeRecipe("org.openrewrite.java.micronaut.Micronaut2to3Migration")
7
}
8
​
9
repositories {
10
    mavenCentral()
11
}
12
​
13
dependencies {
14
    implementation(platform("org.openrewrite.recipe:rewrite-recipe-bom:1.3.0"))
15
    rewrite("org.openrewrite.recipe:rewrite-micronaut")
16
}
Copied!
pom.xml
1
<project>
2
  <dependencyManagement>
3
    <dependencies>
4
        <dependency>
5
            <groupId>org.openrewrite.recipe</groupId>
6
            <artifactId>rewrite-recipe-bom</artifactId>
7
            <version>1.3.0</version>
8
            <type>pom</type>
9
            <scope>import</scope>
10
        </dependency>
11
    </dependencies>
12
  </dependencyManagement>
13
  <build>
14
    <plugins>
15
      <plugin>
16
        <groupId>org.openrewrite.maven</groupId>
17
        <artifactId>rewrite-maven-plugin</artifactId>
18
        <version>4.25.0</version>
19
        <configuration>
20
          <activeRecipes>
21
            <recipe>org.openrewrite.java.micronaut.Micronaut2to3Migration</recipe>
22
          </activeRecipes>
23
        </configuration>
24
        <dependencies>
25
          <dependency>
26
            <groupId>org.openrewrite.recipe</groupId>
27
            <artifactId>rewrite-micronaut</artifactId>
28
          </dependency>
29
        </dependencies>
30
      </plugin>
31
    </plugins>
32
  </build>
33
</project>
Copied!
Maven
Set or update your MAVEN_OPTS environment variable to include this content:
MAVEN_OPS environment variable
1
MAVEN_OPTS="--add-exports jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED --add-exports jdk.compiler/com.sun.tools.javac.comp=ALL-UNNAMED --add-exports jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED --add-exports jdk.compiler/com.sun.tools.javac.jvm=ALL-UNNAMED --add-exports jdk.compiler/com.sun.tools.javac.main=ALL-UNNAMED --add-exports jdk.compiler/com.sun.tools.javac.model=ALL-UNNAMED --add-exports jdk.compiler/com.sun.tools.javac.processing=ALL-UNNAMED --add-exports jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED --add-exports jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED"
Copied!
At this point, you're ready to execute the migration by running mvn rewrite:run or gradlew rewriteRun. After running the migration you can inspect the results with git diff (or equivalent), manually fix anything that wasn't able to be migrated automatically, and commit the results.
Before and After
For the full list of changes this recipe will make, see its reference page.
Deprecated Exception Handler constructors
Several micronaut ExceptionHandlers have been refactored such that the no-args constructor has been deprecated and replaced with one taking an ErrorResponseProcessor.
Before
After
1
import io.micronaut.validation.exceptions.ConstraintExceptionHandler;
2
public class ApiClientValidationExceptionHandler extends ConstraintExceptionHandler {
3
    ...
4
}
Copied!
1
import io.micronaut.validation.exceptions.ConstraintExceptionHandler;
2
import jakarta.inject.Inject;
3
​
4
public class ApiClientValidationExceptionHandler extends ConstraintExceptionHandler {
5
​
6
    @Inject
7
    public ApiClientValidationExceptionHandler(ErrorResponseProcessor errorResponseProcessor) {
8
        super(errorResponseProcessor);
9
    }
10
    ...
11
}
Copied!
Subclasses Returned From Factories Not Injectable
It is no longer possible to inject the internal implementation type from beans produced via factories. The type returned from the factory or any of its supertypes are able to be injected.
Before
After
1
import java.util.concurrent.ForkJoinPool;
2
import java.util.concurrent.ExecutorService;
3
import javax.inject.Singleton;
4
​
5
public class ExecutorFactory {
6
​
7
    @Singleton
8
    public ExecutorService executorService() {
9
        return ForkJoinPool.commonPool();
10
    }
11
}
Copied!
1
import java.util.concurrent.ForkJoinPool;
2
import java.util.concurrent.ExecutorService;
3
import javax.inject.Singleton;
4
​
5
public class ExecutorFactory {
6
​
7
    @Singleton
8
    public ForkJoinPool executorService() {
9
        return ForkJoinPool.commonPool();
10
    }
11
}
Copied!
Reflective Bean Map
In several places in Micronaut, it is required to get a map representation of your object. In previous versions, a reflection based strategy was used to retrieve that information if the class was not annotated with @Introspected. That functionality has been removed and it is now required to annotate classes with @Introspected that are being used in this way. Any class may be affected if it is passed as an argument or returned from any controller or client, among other use cases.
Controller
Dto Before
Dto After
1
import io.micronaut.http.annotation.Controller;
2
import io.micronaut.http.annotation.Post;
3
​
4
@Controller("/orders")
5
public class OrdersController {
6
    @Get("/order")
7
    public Order getOrder(Long orderId) {
8
        ...
9
        return order;
10
    }
11
}
Copied!
1
public class Order {
2
    ...
3
}
Copied!
1
import io.micronaut.core.annotation.Introspected;
2
​
3
@Introspected
4
public class Order {
5
    ...
6
}
Copied!
Known Limitations
Unsupported Functionality
Issue
Maybe add RxJava2 dependencies
​#26​
Non-Inherited annotations from super-class method are not copied to overriden method
​#13​
DefaultContext doCreateBean deprecated
​#23​
DefaultHttpHostResolver constructor arg Provider to BeanProvider
​#22​
Change io.micronaut.core.beans.PropertyDescriptor to BeanProperty
​#21​

Tutorials & Guides - Previous

Migrate to Quarkus 2 from Quarkus 1

Next - Tutorials & Guides

Migrate to SLF4J from Log4j

Last modified 3d ago

Export as PDF

Copy link

Contents

Example Configuration

Before and After

Known Limitations