Merge pull request #15800 from apache/fix/15374-codec-metaclass-registration-overhead

Reduce cached codec metaclass registration overhead

Author: jamesfredley

grails-codecs/src/main/groovy/org/grails/plugins/codecs/CodecsConfiguration.java

@@ -36,9 +36,7 @@ public class CodecsConfiguration {
 
     @Bean("codecLookup")
     @Primary
-    public CodecLookup codecLookup(GrailsApplication grailsApplication) throws Exception {
-        final DefaultCodecLookup defaultCodecLookup = new DefaultCodecLookup(grailsApplication);
-        defaultCodecLookup.reInitialize();
-        return defaultCodecLookup;
+    public CodecLookup codecLookup(GrailsApplication grailsApplication) {
+        return new DefaultCodecLookup(grailsApplication);
     }
 }

grails-codecs/src/test/groovy/org/grails/plugins/codecs/CodecsConfigurationSpec.groovy

@@ -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.plugins.codecs
+
+import grails.core.DefaultGrailsApplication
+import grails.core.GrailsApplication
+import org.grails.encoder.CodecLookup
+import org.springframework.context.annotation.AnnotationConfigApplicationContext
+import spock.lang.Specification
+
+class CodecsConfigurationSpec extends Specification {
+
+    void 'registers codec artefacts during Spring context initialization'() {
+        given:
+            DefaultGrailsApplication grailsApplication = new DefaultGrailsApplication(HTMLCodec)
+            grailsApplication.initialise()
+            AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext()
+            context.beanFactory.registerSingleton(GrailsApplication.APPLICATION_ID, grailsApplication)
+            context.register(CodecsConfiguration)
+
+        when:
+            context.refresh()
+            CodecLookup codecLookup = context.getBean(CodecLookup)
+
+        then:
+            codecLookup.lookupEncoder('HTML') != null
+            codecLookup.lookupEncoder('HTML').encode('<tag>') == '&lt;tag&gt;'
+
+        cleanup:
+            context.close()
+    }
+}

grails-encoder/build.gradle

@@ -39,6 +39,7 @@ dependencies {
     implementation platform(project(':grails-bom'))
 
     api project(':grails-core')
+    implementation 'com.github.ben-manes.caffeine:caffeine'
     api 'org.apache.groovy:groovy'
     api 'org.apache.groovy:groovy-json'
     api 'org.springframework:spring-web', {
@@ -63,4 +64,4 @@ dependencies {
 apply {
     from rootProject.layout.projectDirectory.file('gradle/docs-config.gradle')
     from rootProject.layout.projectDirectory.file('gradle/test-config.gradle')
-}
+}

grails-encoder/src/main/groovy/org/grails/encoder/CodecMetaClassSupport.groovy

@@ -18,7 +18,13 @@
  */
 package org.grails.encoder
 
+import java.util.concurrent.ConcurrentHashMap
+
+import com.github.benmanes.caffeine.cache.Cache
+import com.github.benmanes.caffeine.cache.Caffeine
+
 import groovy.transform.CompileStatic
+import groovy.transform.EqualsAndHashCode
 import org.codehaus.groovy.runtime.GStringImpl
 import org.codehaus.groovy.runtime.NullObject
 
@@ -38,6 +44,9 @@ class CodecMetaClassSupport {
     static final Object[] EMPTY_ARGS = []
     static final String ENCODE_AS_PREFIX = 'encodeAs'
     static final String DECODE_PREFIX = 'decode'
+    private static final Cache<CodecFactory, Set<MetaMethodRegistrationKey>> REGISTERED_META_METHODS = Caffeine.newBuilder()
+            .weakKeys()
+            .build()
 
     /**
      * Adds "encodeAs*" and "decode*" metamethods for given codecClass
@@ -101,14 +110,15 @@ class CodecMetaClassSupport {
             }
         }
 
-        addMetaMethod(targetMetaClasses, encodeMethodName, encoderClosure)
+        Set<MetaMethodRegistrationKey> registeredMetaMethodKeys = cacheLookup ? registeredMetaMethodKeys(codecFactory) : null
+        registerMetaMethod(targetMetaClasses, encodeMethodName, encoderClosure, cacheLookup, registeredMetaMethodKeys)
         if (codecFactory.encoder) {
-            addAliasMetaMethods(targetMetaClasses, codecFactory.encoder.codecIdentifier.codecAliases, encodeMethodNameClosure, encoderClosure)
+            addAliasMetaMethods(targetMetaClasses, codecFactory.encoder.codecIdentifier.codecAliases, encodeMethodNameClosure, encoderClosure, cacheLookup, registeredMetaMethodKeys)
         }
 
-        addMetaMethod(targetMetaClasses, decodeMethodName, decoderClosure)
+        registerMetaMethod(targetMetaClasses, decodeMethodName, decoderClosure, cacheLookup, registeredMetaMethodKeys)
         if (codecFactory.decoder) {
-            addAliasMetaMethods(targetMetaClasses, codecFactory.decoder.codecIdentifier.codecAliases, decodeMethodNameClosure, decoderClosure)
+            addAliasMetaMethods(targetMetaClasses, codecFactory.decoder.codecIdentifier.codecAliases, decodeMethodNameClosure, decoderClosure, cacheLookup, registeredMetaMethodKeys)
         }
     }
 
@@ -129,13 +139,14 @@ class CodecMetaClassSupport {
     }
 
     @CompileStatic
-    private addAliasMetaMethods(List<ExpandoMetaClass> targetMetaClasses, Set<String> aliases, Closure<String> methodNameClosure, Closure methodClosure) {
+    private addAliasMetaMethods(List<ExpandoMetaClass> targetMetaClasses, Set<String> aliases, Closure<String> methodNameClosure, Closure methodClosure,
+            boolean cacheLookup, Set<MetaMethodRegistrationKey> registeredMetaMethodKeys) {
         aliases?.each { String aliasName ->
-            addMetaMethod(targetMetaClasses, methodNameClosure(aliasName), methodClosure)
+            registerMetaMethod(targetMetaClasses, methodNameClosure(aliasName), methodClosure, cacheLookup, registeredMetaMethodKeys)
         }
     }
 
-    private String resolveCodecName(CodecFactory codecFactory) {
+    private static String resolveCodecName(CodecFactory codecFactory) {
         codecFactory.encoder?.codecIdentifier?.codecName ?: codecFactory.decoder?.codecIdentifier?.codecName
     }
 
@@ -156,4 +167,53 @@ class CodecMetaClassSupport {
             emc."${methodName}" << closure
         }
     }
+
+    private void registerMetaMethod(List<ExpandoMetaClass> targetMetaClasses, String methodName, Closure closure, boolean cacheLookup,
+            Set<MetaMethodRegistrationKey> registeredMetaMethodKeys) {
+        if (!cacheLookup) {
+            addMetaMethod(targetMetaClasses, methodName, closure)
+            return
+        }
+
+        synchronized (registeredMetaMethodKeys) {
+            List<ExpandoMetaClass> metaClassesToRegister = targetMetaClasses.findAll { ExpandoMetaClass emc ->
+                shouldRegisterMetaMethod(emc, methodName, registeredMetaMethodKeys)
+            }
+            if (metaClassesToRegister) {
+                addMetaMethod(metaClassesToRegister, methodName, closure)
+            }
+        }
+    }
+
+    @CompileStatic
+    private static boolean shouldRegisterMetaMethod(ExpandoMetaClass emc, String methodName, Set<MetaMethodRegistrationKey> registeredMetaMethodKeys) {
+        MetaMethodRegistrationKey key = registrationKey(emc, methodName)
+        registeredMetaMethodKeys.add(key) || emc.getMetaMethod(methodName, EMPTY_ARGS) == null
+    }
+
+    @CompileStatic
+    private static MetaMethodRegistrationKey registrationKey(ExpandoMetaClass emc, String methodName) {
+        new MetaMethodRegistrationKey(emc.getTheClass(), methodName)
+    }
+
+    @CompileStatic
+    private static Set<MetaMethodRegistrationKey> registeredMetaMethodKeys(CodecFactory codecFactory) {
+        REGISTERED_META_METHODS.get(codecFactory) { CodecFactory ignored ->
+            Collections.newSetFromMap(new ConcurrentHashMap<MetaMethodRegistrationKey, Boolean>())
+        }
+    }
+
+    @CompileStatic
+    @EqualsAndHashCode(includeFields = true)
+    private static class MetaMethodRegistrationKey {
+
+        private final Class<?> targetClass
+        private final String methodName
+
+        MetaMethodRegistrationKey(Class<?> targetClass, String methodName) {
+            this.targetClass = targetClass
+            this.methodName = methodName
+        }
+
+    }
 }