GRAILS-6790 - register the auto proxy creator in the “root” application context so that any configuration made by plugins/apps apply to our proxy creator.

Author: ldaley

src/java/org/codehaus/groovy/grails/plugins/CoreGrailsPlugin.groovy

@@ -35,7 +35,9 @@ import org.codehaus.groovy.grails.support.proxy.DefaultProxyHandler
 import org.springframework.beans.factory.config.CustomEditorConfigurer
 import org.springframework.beans.factory.config.MethodInvokingFactoryBean
 import org.springframework.beans.factory.xml.XmlBeanFactory
+import org.springframework.aop.config.AopConfigUtils
 import org.springframework.core.io.Resource
+import org.springframework.beans.factory.support.GenericBeanDefinition
 import org.codehaus.groovy.grails.aop.framework.autoproxy.GroovyAwareAspectJAwareAdvisorAutoProxyCreator
 
 /**
@@ -56,15 +58,18 @@ class CoreGrailsPlugin {
         addBeanFactoryPostProcessor(new MapBasedSmartPropertyOverrideConfigurer(application))
         addBeanFactoryPostProcessor(new GrailsPlaceholderConfigurer())
 
-        // replace AutoProxy advisor with Groovy aware one
         def grailsConfig = application.config.grails
         def springConfig = grailsConfig.spring
-        if(springConfig.disable.aspectj.autoweaving) {
-            "org.springframework.aop.config.internalAutoProxyCreator"(GroovyAwareInfrastructureAdvisorAutoProxyCreator)
-        }
-        else {
-            "org.springframework.aop.config.internalAutoProxyCreator"(GroovyAwareAspectJAwareAdvisorAutoProxyCreator)
-        }
+
+        // configure a Groovy aware AutoProxy advisor
+        // we need to do this on the parent context to allow
+        // plugins/apps to affect it while creating/configing beans
+        // See GRAILS-6790
+        def aspectJDisabled = springConfig.disable.aspectj.autoweaving
+        def proxyCreatorType = aspectJDisabled ? GroovyAwareInfrastructureAdvisorAutoProxyCreator : GroovyAwareAspectJAwareAdvisorAutoProxyCreator
+        def proxyCreatorDefinition = new GenericBeanDefinition()
+        proxyCreatorDefinition.beanClass = proxyCreatorType
+        parentCtx.beanFactory.registerBeanDefinition(AopConfigUtils.AUTO_PROXY_CREATOR_BEAN_NAME, proxyCreatorDefinition)
 
         // Allow the use of Spring annotated components
         context.'annotation-config'()

src/java/org/codehaus/groovy/grails/support/MockApplicationContext.java

@@ -50,6 +50,7 @@
 import org.springframework.util.AntPathMatcher;
 import org.springframework.util.PathMatcher;
 import org.springframework.web.context.WebApplicationContext;
+import org.springframework.beans.factory.support.BeanDefinitionRegistry;
 
 public class MockApplicationContext extends GroovyObjectSupport implements WebApplicationContext {
 
@@ -59,6 +60,7 @@ public class MockApplicationContext extends GroovyObjectSupport implements WebAp
     List<String> ignoredClassLocations = new ArrayList<String>();
     PathMatcher pathMatcher = new AntPathMatcher();
     ServletContext servletContext = new MockServletContext();
+    DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
 
     public void registerMockBean(String name, Object instance) {
         beans.put(name, instance);
@@ -113,6 +115,10 @@ public ApplicationContext getParent() {
         throw new UnsupportedOperationException("Method not supported by implementation");
     }
 
+    BeanFactory getBeanFactory() {
+        return beanFactory;
+    }
+    
     public String getId() {
         return "MockApplicationContext";
     }
@@ -193,26 +199,30 @@ public Map<String, Object> getBeansWithAnnotation(Class<? extends Annotation> an
 
     public Object getBean(String name) throws BeansException {
         if (!beans.containsKey(name)) {
-            throw new NoSuchBeanDefinitionException(name);
+            if (!beanFactory.containsBean(name)) {
+                throw new NoSuchBeanDefinitionException(name);
+            } else {
+                return beanFactory.getBean(name);
+            }
+        } else {
+            return beans.get(name);
         }
-        return beans.get(name);
     }
 
     @SuppressWarnings("unchecked")
     public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
-        if (!beans.containsKey(name)) {
-            throw new NoSuchBeanDefinitionException( name);
-        }
+        Object bean = getBean(name);
 
-        if (requiredType != null && !requiredType.isAssignableFrom(beans.get(name).getClass())) {
+        if (requiredType != null && !requiredType.isAssignableFrom(bean.getClass())) {
             throw new NoSuchBeanDefinitionException(name);
         }
 
-        return (T)beans.get(name);
+        return (T)bean;
     }
 
     public <T> T getBean(Class<T> tClass) throws BeansException {
         final Map<String, T> map = getBeansOfType(tClass);
+        map.putAll(beanFactory.getBeansOfType(tClass));
         if (map.isEmpty()) {
             throw new NoSuchBeanDefinitionException(tClass, "No bean found for type: "  + tClass.getName());
         }
@@ -329,7 +339,7 @@ public boolean containsLocalBean(String arg0) {
     }
 
     public AutowireCapableBeanFactory getAutowireCapableBeanFactory() throws IllegalStateException {
-        return new DefaultListableBeanFactory();
+        return beanFactory;
     }
     public ClassLoader getClassLoader() {
         return getClass().getClassLoader();

src/test/org/codehaus/groovy/grails/plugins/CoreGrailsPluginTests.groovy

@@ -6,6 +6,8 @@ import org.codehaus.groovy.grails.commons.test.AbstractGrailsMockTests
 import org.codehaus.groovy.grails.aop.framework.autoproxy.GroovyAwareAspectJAwareAdvisorAutoProxyCreator
 import org.codehaus.groovy.grails.aop.framework.autoproxy.GroovyAwareInfrastructureAdvisorAutoProxyCreator
 
+import grails.spring.BeanBuilder
+
 class CoreGrailsPluginTests extends AbstractGrailsMockTests {
 
     void testCorePlugin() {
@@ -115,4 +117,37 @@ class CoreGrailsPluginTests extends AbstractGrailsMockTests {
         assertEquals(1, appCtx.getBean('someTransactionalService').i)
         assertEquals(2, appCtx.getBean('nonTransactionalService').i)
     }
+    
+    // See GRAILS-6790
+    void testAopConfigurationIsEffective() {
+        def pluginClass = gcl.loadClass("org.codehaus.groovy.grails.plugins.CoreGrailsPlugin")
+        def plugin = new DefaultGrailsPlugin(pluginClass, ga)
+        def springConfig = new WebRuntimeSpringConfiguration(ctx)
+        
+        plugin.doWithRuntimeConfiguration(springConfig)
+        
+        def bb = new BeanBuilder(ctx, springConfig, null)
+        bb.beans {
+            xmlns aop: "http://www.springframework.org/schema/aop"
+
+            aop.config("proxy-target-class": true) {
+
+                aspect(id: "myPlainJavaAspect-id", ref: "myAspect") { 
+                    "before" method: "myBeforeAdvice", pointcut: "execution(* myMethod1(..))" 
+                }
+            }
+
+            myInterfaceImpl(CoreGrailsPluginTestsAopConfig.MyInterfaceImpl)
+            myAspect(CoreGrailsPluginTestsAopConfig.MyAspect)
+        }
+
+        def appCtx = springConfig.getApplicationContext()
+        def bean = appCtx.getBean("myInterfaceImpl")
+
+        // if we can call the following method, then the proxy was class based
+        // because 'myMethod2' is not on the only interface this implements
+        bean.myMethod2()
+    }
+    
+    
 }

src/test/org/codehaus/groovy/grails/plugins/CoreGrailsPluginTestsAopConfig.java

@@ -0,0 +1,18 @@
+package org.codehaus.groovy.grails.plugins;
+
+// Used in CoreGrailsPluginTests#testAopConfigurationIsEffective
+// Must be Java because Groovy classes are always proxy by class
+class CoreGrailsPluginTestsAopConfig {
+    static public class MyAspect {
+        public void myBeforeAdvice() {}
+    }
+    
+    static public interface MyInterface { 
+        void myMethod1(); 
+    }
+    
+    static public class MyInterfaceImpl implements MyInterface {
+        public void myMethod1() {}
+        public void myMethod2() {}
+    }
+}