Make i18n and URL-mappings framework beans overridable (@ConditionalOnMissingBean)

grails-controllers/build.gradle

@@ -64,6 +64,8 @@ dependencies {
 
     testImplementation 'jakarta.servlet:jakarta.servlet-api'
     testImplementation 'org.springframework:spring-test'
+    testImplementation 'org.springframework.boot:spring-boot-test'
+    testRuntimeOnly 'org.assertj:assertj-core'
 
     testImplementation 'org.apache.groovy:groovy-test-junit5'
     testImplementation 'org.junit.jupiter:junit-jupiter-api'

grails-controllers/src/main/groovy/org/grails/plugins/web/controllers/ControllersAutoConfiguration.java

@@ -109,13 +109,25 @@ public FilterRegistrationBean<Filter> hiddenHttpMethodFilter() {
         return registrationBean;
     }
 
+    // Exposed as a RequestContextFilter bean (GrailsWebRequestFilter extends it) so that Boot's
+    // WebMvcAutoConfiguration RequestContextFilter — @ConditionalOnMissingBean(RequestContextFilter) —
+    // backs off in favour of Grails' GrailsWebRequest binding. Without @EnableWebMvc, Boot's
+    // WebMvcAutoConfiguration is active and would otherwise register an OrderedRequestContextFilter
+    // (order -105) that rebinds a plain ServletRequestAttributes between GrailsWebRequestFilter (-150)
+    // and the Spring Security chain (-100), causing a GrailsWebRequest ClassCastException downstream.
     @Bean
     @ConditionalOnMissingBean(GrailsWebRequestFilter.class)
-    public FilterRegistrationBean<Filter> grailsWebRequestFilter(ApplicationContext applicationContext) {
-        FilterRegistrationBean<Filter> registrationBean = new FilterRegistrationBean<>();
+    public GrailsWebRequestFilter grailsWebRequest(ApplicationContext applicationContext) {
         GrailsWebRequestFilter grailsWebRequestFilter = new GrailsWebRequestFilter();
         grailsWebRequestFilter.setApplicationContext(applicationContext);
-        registrationBean.setFilter(grailsWebRequestFilter);
+        return grailsWebRequestFilter;
+    }
+
+    @Bean
+    @ConditionalOnMissingBean(name = "grailsWebRequestFilter")
+    public FilterRegistrationBean<GrailsWebRequestFilter> grailsWebRequestFilter(GrailsWebRequestFilter grailsWebRequest) {
+        FilterRegistrationBean<GrailsWebRequestFilter> registrationBean = new FilterRegistrationBean<>();
+        registrationBean.setFilter(grailsWebRequest);
         registrationBean.setDispatcherTypes(EnumSet.of(
                 DispatcherType.FORWARD,
                 DispatcherType.INCLUDE,
@@ -153,6 +165,7 @@ public DispatcherServletRegistrationBean dispatcherServletRegistration(GrailsApp
     }
 
     @Bean
+    @ConditionalOnMissingBean(GrailsWebMvcConfigurer.class)
     public GrailsWebMvcConfigurer webMvcConfig() {
         return new GrailsWebMvcConfigurer(resourcesCachePeriod, resourcesEnabled, resourcesPattern);
     }

grails-controllers/src/main/groovy/org/grails/plugins/web/controllers/GrailsViewResolverAutoConfiguration.java

@@ -0,0 +1,85 @@
+/*
+ *  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.plugins.web.controllers;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import org.springframework.beans.factory.support.BeanDefinitionRegistry;
+import org.springframework.boot.autoconfigure.AutoConfiguration;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnWebApplication;
+import org.springframework.boot.webmvc.autoconfigure.WebMvcAutoConfiguration;
+import org.springframework.context.EnvironmentAware;
+import org.springframework.context.annotation.Import;
+import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
+import org.springframework.core.env.Environment;
+import org.springframework.core.type.AnnotationMetadata;
+
+import grails.config.Settings;
+
+/**
+ * Without the auto-injected {@code @EnableWebMvc}, Spring Boot's
+ * {@link WebMvcAutoConfiguration} is active and contributes a {@code defaultViewResolver}
+ * ({@code InternalResourceViewResolver}). For a Grails application that does not use
+ * JSP/InternalResource views (e.g. a REST/JSON-views app) this catch-all resolver resolves
+ * any unmatched view name to a servlet forward, producing
+ * {@code Circular view path [index]: would dispatch back to the current handler URL} errors.
+ *
+ * This is the single place the {@code defaultViewResolver} is removed for every Grails servlet
+ * web application (GSP, JSON/Markup or plain), so Grails' own view resolution is used instead.
+ * grails-gsp only loads for GSP applications, so the removal cannot live there. Ordered after
+ * {@link WebMvcAutoConfiguration} so the bean exists by the time the registrar runs.
+ *
+ * <p>Disable with {@code grails.web.removeDefaultViewResolverBean=false}. The earlier
+ * {@code spring.gsp.removeDefaultViewResolverBean} (when removal lived in grails-gsp) is still
+ * honoured for backward compatibility, but is deprecated.
+ */
+@AutoConfiguration(after = WebMvcAutoConfiguration.class)
+@ConditionalOnWebApplication(type = ConditionalOnWebApplication.Type.SERVLET)
+@Import(GrailsViewResolverAutoConfiguration.RemoveDefaultViewResolverRegistrar.class)
+public class GrailsViewResolverAutoConfiguration {
+
+    static final String REMOVE_PROPERTY = Settings.WEB_REMOVE_DEFAULT_VIEW_RESOLVER_BEAN;
+    static final String LEGACY_REMOVE_PROPERTY = "spring.gsp.removeDefaultViewResolverBean";
+
+    static class RemoveDefaultViewResolverRegistrar implements ImportBeanDefinitionRegistrar, EnvironmentAware {
+
+        private static final Logger LOG = LoggerFactory.getLogger(RemoveDefaultViewResolverRegistrar.class);
+
+        private boolean removeDefaultViewResolverBean = true;
+
+        @Override
+        public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
+            if (removeDefaultViewResolverBean && registry.containsBeanDefinition("defaultViewResolver")) {
+                registry.removeBeanDefinition("defaultViewResolver");
+            }
+        }
+
+        @Override
+        public void setEnvironment(Environment environment) {
+            // Honour the legacy grails-gsp property name for backward compatibility (deprecated).
+            Boolean legacy = environment.getProperty(LEGACY_REMOVE_PROPERTY, Boolean.class);
+            if (legacy != null) {
+                LOG.warn("'{}' is deprecated; use '{}' instead.", LEGACY_REMOVE_PROPERTY, REMOVE_PROPERTY);
+            }
+            this.removeDefaultViewResolverBean = environment.getProperty(
+                    REMOVE_PROPERTY, Boolean.class, legacy != null ? legacy : true);
+        }
+    }
+}

grails-controllers/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports

@@ -1 +1,2 @@
 org.grails.plugins.web.controllers.ControllersAutoConfiguration
+org.grails.plugins.web.controllers.GrailsViewResolverAutoConfiguration

grails-controllers/src/test/groovy/org/grails/plugins/web/controllers/ControllersAutoConfigurationSpec.groovy

@@ -0,0 +1,136 @@
+/*
+ *  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.plugins.web.controllers
+
+import java.util.function.Supplier
+
+import grails.core.GrailsApplication
+
+import org.springframework.boot.autoconfigure.AutoConfigurations
+import org.springframework.boot.test.context.runner.WebApplicationContextRunner
+import org.springframework.boot.web.servlet.FilterRegistrationBean
+import org.springframework.boot.webmvc.autoconfigure.WebMvcAutoConfiguration
+import org.springframework.context.ApplicationContext
+import org.springframework.web.filter.RequestContextFilter
+
+import org.grails.web.config.http.GrailsFilters
+import org.grails.web.servlet.mvc.GrailsWebRequestFilter
+
+import spock.lang.Specification
+
+class ControllersAutoConfigurationSpec extends Specification {
+
+    ApplicationContext applicationContext = Mock(ApplicationContext) {
+        getBeansOfType(_) >> [:]
+    }
+
+    ControllersAutoConfiguration autoConfiguration = new ControllersAutoConfiguration()
+
+    void 'grailsWebRequest filter is a RequestContextFilter so Boot WebMvcAutoConfiguration backs off its own RequestContextFilter'() {
+        when: 'the Grails request-binding filter bean is created'
+        GrailsWebRequestFilter filter = autoConfiguration.grailsWebRequest(applicationContext)
+
+        then: 'it is exposed as a RequestContextFilter, the type Boot @ConditionalOnMissingBean keys on'
+        filter != null
+        filter instanceof RequestContextFilter
+    }
+
+    void 'grailsWebRequestFilter registers the GrailsWebRequestFilter with the Grails request-filter order'() {
+        given: 'the Grails request-binding filter'
+        GrailsWebRequestFilter filter = autoConfiguration.grailsWebRequest(applicationContext)
+
+        when: 'it is wrapped in a registration bean'
+        FilterRegistrationBean<GrailsWebRequestFilter> registrationBean = autoConfiguration.grailsWebRequestFilter(filter)
+
+        then: 'the same filter instance is registered ahead of the Spring Security chain'
+        registrationBean.filter.is(filter)
+        registrationBean.order == GrailsFilters.GRAILS_WEB_REQUEST_FILTER.order
+    }
+
+    void 'Boot WebMvcAutoConfiguration registers its own requestContextFilter when the Grails controllers auto-config is absent'() {
+        expect: 'the contrast case proves the backoff assertion below is meaningful'
+        new WebApplicationContextRunner()
+                .withConfiguration(AutoConfigurations.of(WebMvcAutoConfiguration))
+                .run { context ->
+                    assert context.containsBean('requestContextFilter')
+                }
+    }
+
+    void 'Grails controllers auto-config makes Boot WebMvcAutoConfiguration back off its requestContextFilter'() {
+        given: 'a GrailsApplication, required by the controllers auto-config'
+        GrailsApplication grailsApplication = Mock(GrailsApplication) {
+            getClassLoader() >> getClass().classLoader
+        }
+        Supplier<GrailsApplication> grailsApplicationSupplier = () -> grailsApplication
+
+        expect: 'Boot does not contribute its OrderedRequestContextFilter, leaving GrailsWebRequest bound'
+        new WebApplicationContextRunner()
+                .withBean(GrailsApplication, grailsApplicationSupplier)
+                .withConfiguration(AutoConfigurations.of(ControllersAutoConfiguration, WebMvcAutoConfiguration))
+                .run { context ->
+                    assert !context.containsBean('requestContextFilter')
+                    assert context.getBeanNamesForType(GrailsWebRequestFilter).length == 1
+                }
+    }
+
+    void 'a user-defined grailsWebRequestFilter registration bean makes the auto-configured one back off'() {
+        given: 'a GrailsApplication, required by the controllers auto-config'
+        GrailsApplication grailsApplication = Mock(GrailsApplication) {
+            getClassLoader() >> getClass().classLoader
+        }
+        Supplier<GrailsApplication> grailsApplicationSupplier = () -> grailsApplication
+
+        and: 'a user-defined registration bean under the auto-configured bean name'
+        FilterRegistrationBean<GrailsWebRequestFilter> userRegistration = new FilterRegistrationBean<>()
+        Supplier<FilterRegistrationBean> userRegistrationSupplier = () -> userRegistration
+
+        expect: 'the user bean wins and the auto-configuration does not register a second one'
+        new WebApplicationContextRunner()
+                .withBean(GrailsApplication, grailsApplicationSupplier)
+                .withBean('grailsWebRequestFilter', FilterRegistrationBean, userRegistrationSupplier)
+                .withConfiguration(AutoConfigurations.of(ControllersAutoConfiguration, WebMvcAutoConfiguration))
+                .run { context ->
+                    assert context.getBean('grailsWebRequestFilter').is(userRegistration)
+                }
+    }
+
+    void 'a user-defined GrailsWebMvcConfigurer bean makes the auto-configured webMvcConfig back off'() {
+        given: 'a GrailsApplication, required by the controllers auto-config'
+        GrailsApplication grailsApplication = Mock(GrailsApplication) {
+            getClassLoader() >> getClass().classLoader
+        }
+        Supplier<GrailsApplication> grailsApplicationSupplier = () -> grailsApplication
+
+        and: 'a user-defined web MVC configurer'
+        def userConfigurer = new ControllersAutoConfiguration.GrailsWebMvcConfigurer(0, false, '/custom/**')
+        Supplier<ControllersAutoConfiguration.GrailsWebMvcConfigurer> userConfigurerSupplier = () -> userConfigurer
+
+        expect: 'the user bean wins and only one GrailsWebMvcConfigurer exists'
+        new WebApplicationContextRunner()
+                .withBean(GrailsApplication, grailsApplicationSupplier)
+                .withBean(ControllersAutoConfiguration.GrailsWebMvcConfigurer, userConfigurerSupplier)
+                .withConfiguration(AutoConfigurations.of(ControllersAutoConfiguration, WebMvcAutoConfiguration))
+                .run { context ->
+                    def names = context.getBeanNamesForType(ControllersAutoConfiguration.GrailsWebMvcConfigurer)
+                    assert names.length == 1
+                    assert context.getBean(names[0]).is(userConfigurer)
+                }
+    }
+}

grails-controllers/src/test/groovy/org/grails/plugins/web/controllers/GrailsViewResolverAutoConfigurationSpec.groovy

@@ -0,0 +1,79 @@
+/*
+ *  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.plugins.web.controllers
+
+import org.springframework.boot.autoconfigure.AutoConfigurations
+import org.springframework.boot.test.context.runner.WebApplicationContextRunner
+import org.springframework.boot.webmvc.autoconfigure.WebMvcAutoConfiguration
+
+import spock.lang.Specification
+
+class GrailsViewResolverAutoConfigurationSpec extends Specification {
+
+    void 'Boot WebMvcAutoConfiguration contributes a defaultViewResolver when the Grails auto-config is absent'() {
+        expect: 'the contrast case proves the removal assertions below are meaningful'
+        new WebApplicationContextRunner()
+                .withConfiguration(AutoConfigurations.of(WebMvcAutoConfiguration))
+                .run { context ->
+                    assert context.containsBean('defaultViewResolver')
+                }
+    }
+
+    void 'the defaultViewResolver is removed by default'() {
+        expect:
+        new WebApplicationContextRunner()
+                .withConfiguration(AutoConfigurations.of(WebMvcAutoConfiguration, GrailsViewResolverAutoConfiguration))
+                .run { context ->
+                    assert !context.containsBean('defaultViewResolver')
+                }
+    }
+
+    void 'the defaultViewResolver is kept when grails.web.removeDefaultViewResolverBean=false'() {
+        expect:
+        new WebApplicationContextRunner()
+                .withPropertyValues("${GrailsViewResolverAutoConfiguration.REMOVE_PROPERTY}=false")
+                .withConfiguration(AutoConfigurations.of(WebMvcAutoConfiguration, GrailsViewResolverAutoConfiguration))
+                .run { context ->
+                    assert context.containsBean('defaultViewResolver')
+                }
+    }
+
+    void 'the deprecated spring.gsp.removeDefaultViewResolverBean property is still honoured'() {
+        expect:
+        new WebApplicationContextRunner()
+                .withPropertyValues("${GrailsViewResolverAutoConfiguration.LEGACY_REMOVE_PROPERTY}=false")
+                .withConfiguration(AutoConfigurations.of(WebMvcAutoConfiguration, GrailsViewResolverAutoConfiguration))
+                .run { context ->
+                    assert context.containsBean('defaultViewResolver')
+                }
+    }
+
+    void 'the new property takes precedence over the deprecated one'() {
+        expect:
+        new WebApplicationContextRunner()
+                .withPropertyValues(
+                        "${GrailsViewResolverAutoConfiguration.REMOVE_PROPERTY}=true",
+                        "${GrailsViewResolverAutoConfiguration.LEGACY_REMOVE_PROPERTY}=false")
+                .withConfiguration(AutoConfigurations.of(WebMvcAutoConfiguration, GrailsViewResolverAutoConfiguration))
+                .run { context ->
+                    assert !context.containsBean('defaultViewResolver')
+                }
+    }
+}

grails-core/src/main/groovy/grails/config/Settings.groovy

@@ -264,6 +264,12 @@ interface Settings {
      */
     String WEB_SERVLET_PATH = 'grails.web.servlet.path'
 
+    /**
+     * Whether to remove Spring Boot's {@code defaultViewResolver} bean so Grails' own view
+     * resolution is used. Defaults to true
+     */
+    String WEB_REMOVE_DEFAULT_VIEW_RESOLVER_BEAN = 'grails.web.removeDefaultViewResolverBean'
+
     /**
      * The URL of the server
      */

grails-core/src/main/groovy/org/grails/compiler/injection/ApplicationClassInjector.groovy

@@ -144,7 +144,6 @@ class ApplicationClassInjector implements GrailsArtefactClassInjector {
                 addAnnotation('org.springframework.boot.SpringBootConfiguration', classNode)?.with {
                     GrailsASTUtils.addExpressionToAnnotationMember(it, 'proxyBeanMethods', constX(false))
                 }
-                addAnnotation('org.springframework.web.servlet.config.annotation.EnableWebMvc', classNode, 'jakarta.servlet.ServletContext')
                 addAnnotation('org.springframework.boot.autoconfigure.EnableAutoConfiguration', classNode)?.with { annotation ->
                     EXCLUDED_AUTO_CONFIGURE_CLASSES.each {
                         GrailsASTUtils.addExpressionToAnnotationMember(