Merge pull request #15411 from apache/micronaut-fixes-2

Author: jdaugherty

gradle.properties

@@ -56,6 +56,7 @@ gradleCycloneDxPluginVersion=2.4.1
 micronautPlatformVersion=4.9.2
 
 # Libraries only specific to test apps, these should not be exposed
+ersatzVersion=4.0.1
 grailsSpringSecurityVersion=7.0.2-SNAPSHOT
 jbossTransactionApiVersion=2.0.0.Final
 # Note: we do not import the micronaut bom in our tests to avoid spring version mismatches

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

@@ -371,6 +371,24 @@ 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.
+
+The Grails Gradle Plugin automatically configures Groovy-based Micronaut bean registration via AST transforms (`micronaut-inject-groovy` on `compileOnlyApi`). Groovy classes annotated with `@Singleton`, `@Factory`, `@ConfigurationProperties`, etc. are processed automatically.
+
+IMPORTANT: If your project contains **Java source files** with Micronaut annotations (e.g. `@Singleton`, `@Factory`), you must manually add the Micronaut annotation processor to your `build.gradle`. The annotation processor is not configured automatically because it is incompatible with Groovy incremental compilation (see https://github.com/apache/grails-core/issues/15211[#15211]). For projects that mix Java and Groovy Micronaut beans, consider splitting them into separate source sets or modules to avoid incremental compilation issues.
+
+[source,groovy]
+.build.gradle - Adding annotation processor for Java Micronaut beans
+----
+dependencies {
+    annotationProcessor platform("io.micronaut.platform:micronaut-platform:$micronautPlatformVersion")
+    annotationProcessor 'io.micronaut:micronaut-inject-java'
+    annotationProcessor 'jakarta.annotation:jakarta.annotation-api'
+}
+----
+
+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 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)

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

@@ -0,0 +1,48 @@
+/*
+ *  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 java.util.Set;
+
+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;
+
+@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

@@ -19,18 +19,21 @@
 package org.grails.forge.feature.reloading;
 
 import jakarta.inject.Singleton;
+
 import org.grails.forge.application.ApplicationType;
 import org.grails.forge.application.generator.GeneratorContext;
 import org.grails.forge.build.dependencies.Dependency;
 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;
 
 @Singleton
 public class SpringBootDevTools implements ReloadingFeature, DefaultFeature {
+
     @Override
     public String getName() {
         return "spring-boot-devtools";
@@ -43,7 +46,11 @@ public String getTitle() {
 
     @Override
     public String getDescription() {
-        return "Spring Boot Devtools is a powerful tool that enhances development productivity by providing features like automatic application restarts on code changes, live reloading of static resources, and remote debugging support. It enables developers to rapidly iterate and test changes during the development process, making it a valuable asset for Spring Boot projects.";
+        return "Spring Boot Devtools is a powerful tool that enhances development productivity " +
+                "by providing features like automatic application restarts on code changes, live " +
+                "reloading of static resources, and remote debugging support. It enables developers " +
+                "to rapidly iterate and test changes during the development process, making it a " +
+                "valuable asset for Spring Boot projects.";
     }
 
     @Override
@@ -61,6 +68,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

@@ -16,45 +16,45 @@
  *  specific language governing permissions and limitations
  *  under the License.
  */
-
 package org.grails.forge.feature.reloading
 
+import spock.lang.Unroll
+
 import org.grails.forge.ApplicationContextSpec
 import org.grails.forge.application.ApplicationType
-import org.grails.forge.feature.Features
 import org.grails.forge.fixture.CommandOutputFixture
 
 class SpringBootDevToolsSpec extends ApplicationContextSpec implements CommandOutputFixture {
 
     void "test spring-boot-devtools feature"() {
-
-        when:
-        final Features features = getFeatures(["spring-boot-devtools"])
-
-        then:
-        features.contains("spring-boot-devtools")
-
+        expect:
+        'spring-boot-devtools' in getFeatures(['spring-boot-devtools'])
     }
 
-    void "test spring-boot-devtools dependency is present for #applicationType application type"() {
-
+    @Unroll
+    void "test spring-boot-devtools dependency is present for #applicationType application type"(ApplicationType applicationType) {
         when:
-        def output = generate(applicationType, ["spring-boot-devtools"])
-        def build = output["build.gradle"]
+        def output = generate(applicationType, ['spring-boot-devtools'])
+        def build = output['build.gradle']
 
         then:
-        build.contains("developmentOnly \"org.springframework.boot:spring-boot-devtools\"")
+        build.contains('developmentOnly "org.springframework.boot:spring-boot-devtools"')
 
         where:
         applicationType << [ApplicationType.WEB, ApplicationType.REST_API]
     }
 
     void "test there can be only one of Reloading feature"() {
         when:
-        getFeatures(["spring-boot-devtools", "jrebel"])
+        getFeatures(['spring-boot-devtools', 'jrebel'])
 
         then:
         def ex = thrown(IllegalArgumentException)
-        ex.message.contains("There can only be one of the following features selected")
+        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"() {
+        expect:
+        !('spring-boot-devtools' in getFeatures(['grails-micronaut']))
     }
 }

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

@@ -75,6 +75,7 @@ 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.run.BootRun
+import org.springframework.boot.loader.tools.LoaderImplementation
 
 import javax.inject.Inject
 
@@ -381,10 +382,11 @@ class GrailsGradlePlugin extends GroovyPlugin {
                 }
             }
 
-            project.logger.info('Adding Micronaut annotationProcessor dependencies to project {}', 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(BootArchive).configureEach {
+                it.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

@@ -16,13 +16,12 @@
  *  specific language governing permissions and limitations
  *  under the License.
  */
-
 package org.apache.grails.micronaut
 
 import groovy.transform.CompileStatic
 import groovy.util.logging.Slf4j
 
-import io.micronaut.context.ConfigurableApplicationContext
+import io.micronaut.context.ApplicationContext as MicronautApplicationContext
 import io.micronaut.context.env.AbstractPropertySourceLoader
 import io.micronaut.context.env.PropertySource
 
@@ -50,24 +49,39 @@ class GrailsMicronautGrailsPlugin extends Plugin {
         }
 
         if (!applicationContext.containsBean('micronautApplicationContext')) {
-            throw new IllegalStateException('A Micronaut Application Context should exist prior to the loading of the Grails Micronaut 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',
+                MicronautApplicationContext
+        )
         def micronautEnv = micronautContext.environment
 
         log.debug('Loading configurations from the plugins to the parent Micronaut context')
 
         def plugins = pluginManager.allPlugins
-        def pluginsFromContext = pluginManagerFromContext ? pluginManagerFromContext.allPlugins : new GrailsPlugin[0]
+        def pluginsFromContext = pluginManagerFromContext ?
+                pluginManagerFromContext.allPlugins :
+                new GrailsPlugin[0]
         int priority = AbstractPropertySourceLoader.DEFAULT_POSITION
         [plugins, pluginsFromContext].each { pluginsToProcess ->
-            Arrays.stream(pluginsToProcess)
-                    .filter { plugin -> plugin.propertySource != null }
-                    .forEach { plugin ->
-                        log.debug('Loading configurations from {} plugin to the parent Micronaut context', plugin.name)
-                        // If invoking the source as `.source`, the NavigableMapPropertySource will return null, while invoking the getter, it will return the correct value
-                        micronautEnv.addPropertySource(PropertySource.of("grails.plugins.$plugin.name", (Map) plugin.propertySource.getSource(), --priority))
+            pluginsToProcess
+                    .findAll { it.propertySource != null }
+                    .each {
+                        log.debug('Loading configurations from {} plugin to the parent Micronaut context', it.name)
+                        // If invoking the source as `.source`, the NavigableMapPropertySource will return null,
+                        // while invoking the getter, it will return the correct value
+                        micronautEnv.addPropertySource(
+                                PropertySource.of(
+                                        "grails.plugins.$it.name",
+                                        (Map) it.propertySource.getSource(),
+                                        --priority
+                                )
+                        )
                     }
         }
         micronautEnv.refresh()

grails-test-examples/micronaut-groovy-only/build.gradle

@@ -0,0 +1,52 @@
+/*
+ *  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.
+ */
+plugins {
+    id 'org.apache.grails.buildsrc.properties'
+    id 'org.apache.grails.buildsrc.compile'
+}
+
+version = '0.1'
+group = 'micronautgroovyonly'
+
+apply plugin: 'org.apache.grails.gradle.grails-web'
+
+// This module intentionally has NO annotationProcessor dependencies.
+// It validates that a Groovy-only Grails application works with
+// grails-micronaut without explicit Java annotation processor configuration.
+// The Grails Gradle plugin automatically applies the required annotation
+// processors when grails-micronaut is present on the classpath.
+
+dependencies {
+    implementation platform(project(':grails-bom'))
+
+    implementation 'org.apache.grails:grails-dependencies-starter-web'
+    implementation 'org.apache.grails:grails-micronaut'
+
+    runtimeOnly 'com.h2database:h2'
+    runtimeOnly 'org.apache.tomcat:tomcat-jdbc'
+
+    testImplementation 'org.apache.grails:grails-dependencies-test'
+
+    integrationTestImplementation testFixtures('org.apache.grails:grails-geb')
+}
+
+apply {
+    from rootProject.layout.projectDirectory.file('gradle/functional-test-config.gradle')
+    from rootProject.layout.projectDirectory.file('gradle/grails-extension-gradle-config.gradle')
+}