fix: configure Micronaut annotation processor and CLASSIC boot loader automatically

grails-doc/src/en/guide/upgrading/upgrading60x.adoc

@@ -371,6 +371,12 @@ Here's an example `gradle.properties` file:
 micronautPlatformVersion=4.9.2
 ----
 
+Please note that, due to https://github.com/micronaut-projects/micronaut-spring/issues/769[this issue], Spring Boot DevTools does not work with the Micronaut integration.
+
+IMPORTANT: Do **not** manually add Micronaut annotation processors (such as `micronaut-inject-java`) to your `build.gradle`. The Grails Gradle Plugin automatically configures the correct annotation processor for Java source files and uses Groovy AST transforms (`micronaut-inject-groovy`) for Groovy source files. Manually adding annotation processors may cause duplicate bean definitions or incremental compilation issues (see https://github.com/apache/grails-core/issues/15211[#15211]).
+
+NOTE: The Grails Gradle Plugin automatically configures the Spring Boot `bootJar` and `bootWar` tasks to use the `CLASSIC` loader implementation when `grails-micronaut` is detected. This is required for `java -jar` execution to work correctly with the Micronaut-Spring integration (see https://github.com/apache/grails-core/issues/15207[#15207]). If you have explicitly set `loaderImplementation` in your `build.gradle`, you can remove it as the Grails Gradle Plugin now handles this automatically.
+
 ===== 12.5 hibernate-ehcache
 
 The `org.hibernate:hibernate-ehcache` library is no longer provided by the `org.apache.grails:grails-hibernate5` plugin. If

grails-forge/grails-forge-core/src/main/java/org/grails/forge/feature/build/gradle/templates/buildGradle.rocker.raw

@@ -98,7 +98,7 @@ repositories {
 compileJava.options.release = @features.getTargetJdk()
 
 @if (features.contains("jrebel")) {
-bootRun {
+tasks.named('bootRun') {
     dependsOn(generateRebel)
     if (project.hasProperty("rebelAgent")) {
         jvmArgs(rebelAgent)
@@ -107,6 +107,17 @@ bootRun {
 
 }
 
+@if (features.contains("grails-micronaut")) {
+tasks.named('bootJar') {
+    loaderImplementation = org.springframework.boot.loader.tools.LoaderImplementation.CLASSIC
+}
+
+tasks.named('bootWar') {
+    loaderImplementation = org.springframework.boot.loader.tools.LoaderImplementation.CLASSIC
+}
+
+}
+
 @if (features.contains("spock")) {
 tasks.withType(Test).configureEach {
     useJUnitPlatform()

grails-forge/grails-forge-core/src/main/java/org/grails/forge/feature/micronaut/GrailsMicronautValidator.java

@@ -0,0 +1,46 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *
+ *    https://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License.
+ */
+package org.grails.forge.feature.micronaut;
+
+import jakarta.inject.Singleton;
+import org.grails.forge.application.ApplicationType;
+import org.grails.forge.feature.Feature;
+import org.grails.forge.feature.reloading.SpringBootDevTools;
+import org.grails.forge.feature.validation.FeatureValidator;
+import org.grails.forge.options.Options;
+
+import java.util.Set;
+
+@Singleton
+public class GrailsMicronautValidator implements FeatureValidator {
+    @Override
+    public void validatePreProcessing(Options options, ApplicationType applicationType, Set<Feature> features) {
+        if (features.stream().anyMatch(f -> f instanceof GrailsMicronaut)) {
+            if (features.stream().anyMatch(f -> (f instanceof SpringBootDevTools))) {
+                // See: https://github.com/micronaut-projects/micronaut-spring/issues/769
+                throw new IllegalArgumentException("Spring Boot Dev Tools are not supported with Grails Micronaut");
+            }
+        }
+    }
+
+    @Override
+    public void validatePostProcessing(Options options, ApplicationType applicationType, Set<Feature> features) {
+
+    }
+}

grails-forge/grails-forge-core/src/main/java/org/grails/forge/feature/reloading/SpringBootDevTools.java

@@ -25,6 +25,7 @@
 import org.grails.forge.build.dependencies.Scope;
 import org.grails.forge.feature.DefaultFeature;
 import org.grails.forge.feature.Feature;
+import org.grails.forge.feature.micronaut.GrailsMicronaut;
 import org.grails.forge.options.Options;
 
 import java.util.Set;
@@ -61,6 +62,9 @@ public boolean isVisible() {
 
     @Override
     public boolean shouldApply(ApplicationType applicationType, Options options, Set<Feature> selectedFeatures) {
+        if (selectedFeatures.stream().anyMatch(f -> f instanceof GrailsMicronaut)) {
+            return false;
+        }
         return selectedFeatures.stream().noneMatch(f -> f instanceof ReloadingFeature);
     }
 

grails-forge/grails-forge-core/src/test/groovy/org/grails/forge/feature/reloading/SpringBootDevToolsSpec.groovy

@@ -57,4 +57,12 @@ class SpringBootDevToolsSpec extends ApplicationContextSpec implements CommandOu
         def ex = thrown(IllegalArgumentException)
         ex.message.contains("There can only be one of the following features selected")
     }
+
+    void "test spring-boot-devtools is not applied when grails-micronaut is selected"() {
+        when:
+        final Features features = getFeatures(["grails-micronaut"])
+
+        then:
+        !features.contains("spring-boot-devtools")
+    }
 }

grails-gradle/plugins/src/main/groovy/org/grails/gradle/plugin/core/GrailsGradlePlugin.groovy

@@ -71,7 +71,10 @@ import org.springframework.boot.gradle.dsl.SpringBootExtension
 import org.springframework.boot.gradle.plugin.ResolveMainClassName
 import org.springframework.boot.gradle.plugin.SpringBootPlugin
 import org.springframework.boot.gradle.tasks.bundling.BootArchive
+import org.springframework.boot.gradle.tasks.bundling.BootJar
+import org.springframework.boot.gradle.tasks.bundling.BootWar
 import org.springframework.boot.gradle.tasks.run.BootRun
+import org.springframework.boot.loader.tools.LoaderImplementation
 
 import javax.inject.Inject
 
@@ -376,10 +379,22 @@ class GrailsGradlePlugin extends GroovyPlugin {
                 }
             }
 
-            project.logger.info('Adding Micronaut annotationProcessor dependencies to project {}', project.name)
+            // Add Micronaut annotation processor for Java source files.
+            // Groovy sources are handled by micronaut-inject-groovy AST transforms (via compileOnlyApi),
+            // but Java sources require the Java annotation processor to generate BeanDefinition classes.
+            // The annotationProcessor configuration only affects compileJava tasks, not compileGroovy.
+            project.logger.info('Adding Micronaut annotationProcessor for Java sources in {}', project.name)
             project.getDependencies().add('annotationProcessor', project.dependencies.platform("io.micronaut.platform:micronaut-platform:$micronautPlatformVersion"))
             project.getDependencies().add('annotationProcessor', 'io.micronaut:micronaut-inject-java')
             project.getDependencies().add('annotationProcessor', 'jakarta.annotation:jakarta.annotation-api')
+
+            project.logger.info('Configuring CLASSIC boot loader for Micronaut compatibility in {}', project.name)
+            project.tasks.withType(BootJar).configureEach { BootJar bootJar ->
+                bootJar.loaderImplementation.convention(LoaderImplementation.CLASSIC)
+            }
+            project.tasks.withType(BootWar).configureEach { BootWar bootWar ->
+                bootWar.loaderImplementation.convention(LoaderImplementation.CLASSIC)
+            }
         }
     }
 

grails-micronaut/build.gradle

@@ -33,11 +33,10 @@ group = 'org.apache.grails'
 dependencies {
     compileOnlyApi platform("io.micronaut.platform:micronaut-platform:$micronautPlatformVersion")
     compileOnlyApi 'io.micronaut:micronaut-inject-groovy'
-    compileOnlyApi 'io.micronaut:micronaut-inject-java'
 
+    // Use the micronaut spring starter so that any bean in the spring context will be exposed to micronaut
     api platform("io.micronaut.platform:micronaut-platform:$micronautPlatformVersion")
     api 'io.micronaut.spring:micronaut-spring-boot-starter'
-    api 'io.micronaut.spring:micronaut-spring-context'
 
     // For the grails plugin interface
     compileOnly platform(project(':grails-bom'))

grails-micronaut/src/main/groovy/org/apache/grails/micronaut/GrailsMicronautGrailsPlugin.groovy

@@ -19,16 +19,15 @@
 
 package org.apache.grails.micronaut
 
+import grails.plugins.GrailsPlugin
 import groovy.transform.CompileStatic
 import groovy.util.logging.Slf4j
 
-import io.micronaut.context.ConfigurableApplicationContext
-import io.micronaut.context.env.AbstractPropertySourceLoader
-import io.micronaut.context.env.PropertySource
-
-import grails.plugins.GrailsPlugin
 import grails.plugins.GrailsPluginManager
 import grails.plugins.Plugin
+import io.micronaut.context.ApplicationContext
+import io.micronaut.context.env.AbstractPropertySourceLoader
+import io.micronaut.context.env.PropertySource
 
 @Slf4j
 @CompileStatic
@@ -53,7 +52,7 @@ class GrailsMicronautGrailsPlugin extends Plugin {
             throw new IllegalStateException('A Micronaut Application Context should exist prior to the loading of the Grails Micronaut plugin.')
         }
 
-        def micronautContext = applicationContext.getBean('micronautApplicationContext', ConfigurableApplicationContext)
+        def micronautContext = applicationContext.getBean('micronautApplicationContext', ApplicationContext)
         def micronautEnv = micronautContext.environment
 
         log.debug('Loading configurations from the plugins to the parent Micronaut context')

grails-test-examples/micronaut/grails-app/conf/application.yml

@@ -48,6 +48,8 @@ spring:
 management:
     endpoints:
         enabled-by-default: false
+app:
+    name: test-micronaut-app
 
 ---
 grails:

grails-test-examples/micronaut/grails-app/controllers/micronaut/MicronautTestController.groovy

@@ -0,0 +1,53 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *
+ *    https://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License.
+ */
+package micronaut
+
+import bean.injection.AppConfig
+import bean.injection.FactoryCreatedService
+import bean.injection.JavaSingletonService
+import bean.injection.NamedService
+import grails.converters.JSON
+import groovy.transform.CompileStatic
+
+import org.springframework.beans.factory.annotation.Autowired
+
+@CompileStatic
+class MicronautTestController {
+
+    @Autowired
+    JavaSingletonService javaSingletonService
+
+    @Autowired
+    FactoryCreatedService factoryCreatedService
+
+    @Autowired
+    AppConfig appConfig
+
+    @Autowired
+    NamedService namedService
+
+    def index() {
+        render([
+            javaMessage: javaSingletonService.message,
+            factoryName: factoryCreatedService.name,
+            appName: appConfig.name,
+            namedService: namedService.name
+        ] as JSON)
+    }
+}

grails-test-examples/micronaut/grails-app/controllers/micronaut/UrlMappings.groovy

@@ -28,6 +28,8 @@ class UrlMappings {
             }
         }
 
+        "/micronaut-test"(controller: 'micronautTest', action: 'index')
+
         "/"(view:"/index")
         "500"(view:'/error')
         "404"(view:'/notFound')

grails-test-examples/micronaut/src/integration-test/groovy/micronaut/MicronautBeanDuplicationSpec.groovy

@@ -0,0 +1,126 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *
+ *    https://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License.
+ */
+package micronaut
+
+import bean.injection.AppConfig
+import bean.injection.FactoryCreatedService
+import bean.injection.JavaSingletonService
+import bean.injection.NamedService
+
+import grails.testing.mixin.integration.Integration
+import io.micronaut.context.ApplicationContext as MicronautApplicationContext
+import org.springframework.beans.factory.annotation.Autowired
+import org.springframework.context.ApplicationContext as SpringApplicationContext
+import org.springframework.context.ApplicationContextAware
+import spock.lang.Specification
+
+/**
+ * Integration tests verifying no bean duplication occurs between Spring and Micronaut contexts.
+ *
+ * When micronaut-spring bridges Micronaut beans into Spring, each bean should appear
+ * exactly once in the Spring context (not duplicated). Similarly, Micronaut beans
+ * should maintain correct counts in the Micronaut context.
+ */
+@Integration
+class MicronautBeanDuplicationSpec extends Specification implements ApplicationContextAware {
+
+    @Autowired
+    MicronautApplicationContext micronautContext
+
+    SpringApplicationContext springContext
+
+    void setApplicationContext(SpringApplicationContext applicationContext) {
+        this.springContext = applicationContext
+    }
+
+    void "Java @Singleton bean appears exactly once in Spring context"() {
+        when:
+        def beans = springContext.getBeansOfType(JavaSingletonService)
+
+        then: "only one instance is registered, not duplicated by the bridge"
+        beans.size() == 1
+    }
+
+    void "@Factory/@Bean created bean appears exactly once in Spring context"() {
+        when:
+        def beans = springContext.getBeansOfType(FactoryCreatedService)
+
+        then: "only one instance is registered"
+        beans.size() == 1
+    }
+
+    void "@ConfigurationProperties bean appears exactly once in Spring context"() {
+        when:
+        def beans = springContext.getBeansOfType(AppConfig)
+
+        then: "only one instance is registered"
+        beans.size() == 1
+    }
+
+    void "NamedService implementations appear exactly 4 times in Spring context"() {
+        when:
+        def beans = springContext.getBeansOfType(NamedService)
+
+        then: "4 implementations, not 8 from duplication"
+        beans.size() == 4
+    }
+
+    void "Micronaut context has exactly 4 NamedService implementations"() {
+        when:
+        def beans = micronautContext.getBeansOfType(NamedService)
+
+        then:
+        beans.size() == 4
+    }
+
+    void "Grails service appears exactly once in Spring context"() {
+        when:
+        def beans = springContext.getBeansOfType(BeanInjectionService)
+
+        then: "Grails artefact not duplicated by Micronaut bridge"
+        beans.size() == 1
+    }
+
+    void "bridged Micronaut bean in Spring is same instance as in Micronaut context"() {
+        when:
+        def fromSpring = springContext.getBean(JavaSingletonService)
+        def fromMicronaut = micronautContext.getBean(JavaSingletonService)
+
+        then: "bridge shares the same singleton, not a copy"
+        fromSpring.is(fromMicronaut)
+    }
+
+    void "factory-created bean in Spring is same instance as in Micronaut context"() {
+        when:
+        def fromSpring = springContext.getBean(FactoryCreatedService)
+        def fromMicronaut = micronautContext.getBean(FactoryCreatedService)
+
+        then: "bridge shares the same singleton"
+        fromSpring.is(fromMicronaut)
+    }
+
+    void "@ConfigurationProperties bean in Spring is same instance as in Micronaut context"() {
+        when:
+        def fromSpring = springContext.getBean(AppConfig)
+        def fromMicronaut = micronautContext.getBean(AppConfig)
+
+        then: "bridge shares the same singleton"
+        fromSpring.is(fromMicronaut)
+    }
+}