Optimize message bundling scanning

graemerocher · graemerocher · commit 1e09ff00555c · 2016-10-03T12:45:26.000+02:00
Searching for message bundles *.properties was scanning the whole classpath which took 2-3 seconds of startup time. This change optimises the scanning to only find bundles relative to the application class. A "searchClasspath" property has been added to the "messageSource" bean to restore the previous behaviour but in 95% of cases this will not be necessary.
diff --git a/grails-core/src/main/groovy/grails/boot/config/GrailsApplicationPostProcessor.groovy b/grails-core/src/main/groovy/grails/boot/config/GrailsApplicationPostProcessor.groovy
@@ -71,7 +71,7 @@ class GrailsApplicationPostProcessor implements BeanDefinitionRegistryPostProces
             this.applicationClass = null
         }
         this.classes = classes != null ? classes : [] as Class[]
-        grailsApplication = new DefaultGrailsApplication()
+        grailsApplication = applicationClass != null ? new DefaultGrailsApplication(applicationClass) : new DefaultGrailsApplication()
         pluginManager = new DefaultGrailsPluginManager(grailsApplication)
         if(applicationContext != null) {
             setApplicationContext(applicationContext)
diff --git a/grails-core/src/main/groovy/grails/core/DefaultGrailsApplication.java b/grails-core/src/main/groovy/grails/core/DefaultGrailsApplication.java
@@ -91,13 +91,22 @@ public class DefaultGrailsApplication extends AbstractGrailsApplication implemen
     protected Class<?>[] allArtefactClassesArray;
     protected Resource[] resources;
     protected boolean initialised = false;
+    protected GrailsApplicationClass applicationClass;
 
     /**
      * Creates a new empty Grails application.
      */
     public DefaultGrailsApplication() {
         this(new GroovyClassLoader());
     }
+
+    /**
+     * Creates a new empty Grails application.
+     */
+    public DefaultGrailsApplication(GrailsApplicationClass applicationClass) {
+        this(new GroovyClassLoader());
+        this.applicationClass = applicationClass;
+    }
     
     public DefaultGrailsApplication(ClassLoader classLoader) {
         super();
@@ -168,6 +177,13 @@ public DefaultGrailsApplication(org.grails.io.support.Resource[] resources) {
         }
     }
 
+    /**
+     * @return The application class
+     */
+    public GrailsApplicationClass getApplicationClass() {
+        return applicationClass;
+    }
+
     /**
      * Initialises the default set of ArtefactHandler instances.
      *
diff --git a/grails-core/src/main/groovy/org/grails/core/support/internal/tools/ClassRelativeClassLoader.java b/grails-core/src/main/groovy/org/grails/core/support/internal/tools/ClassRelativeClassLoader.java
@@ -0,0 +1,70 @@
+package org.grails.core.support.internal.tools;
+
+import grails.io.IOUtils;
+import grails.util.BuildSettings;
+import org.springframework.core.io.FileSystemResource;
+import org.springframework.core.io.Resource;
+import org.springframework.core.io.UrlResource;
+
+import java.io.IOException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.Enumeration;
+
+/**
+ * A classloader that only finds resources and classes that are in the same jar as the given class
+ *
+ * For internal use only
+ *
+ * @author Graeme Rocher
+ * @since 3.1.13
+ */
+class ClassRelativeClassLoader extends URLClassLoader {
+    public ClassRelativeClassLoader(Class targetClass) {
+        super(createClassLoaderUrls(targetClass), ClassLoader.getSystemClassLoader());
+    }
+
+    private static URL[] createClassLoaderUrls(Class targetClass) {
+        URL root = IOUtils.findRootResource(targetClass);
+        if(BuildSettings.RESOURCES_DIR != null && BuildSettings.RESOURCES_DIR.exists()) {
+            try {
+                return new URL[] {root, new FileSystemResource(BuildSettings.RESOURCES_DIR.getCanonicalFile()).getURL() };
+            } catch (IOException e) {
+                return new URL[]{root};
+            }
+        }
+        else {
+            return new URL[]{root};
+        }
+    }
+
+    @Override
+    public URL getResource(String name) {
+        return findResource(name);
+    }
+
+    @Override
+    public Enumeration<URL> getResources(String name) throws IOException {
+        if("".equals(name)) {
+            final URL[] urls = getURLs();
+            final int l = urls.length;
+            return new Enumeration<URL>() {
+                int i = 0;
+                @Override
+                public boolean hasMoreElements() {
+                    return i < l;
+                }
+
+                @Override
+                public URL nextElement() {
+                    return urls[i++];
+                }
+            };
+        }
+        else {
+            return findResources(name);
+        }
+    }
+
+
+}
diff --git a/grails-core/src/main/groovy/org/grails/core/support/internal/tools/ClassRelativeResourcePatternResolver.java b/grails-core/src/main/groovy/org/grails/core/support/internal/tools/ClassRelativeResourcePatternResolver.java
@@ -0,0 +1,24 @@
+package org.grails.core.support.internal.tools;
+
+import org.springframework.core.io.Resource;
+import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
+
+import java.util.Set;
+
+/**
+ * Attempts to limit classpath searching to only locations relative to the given class
+ *
+ * @author Graeme Rocher
+ * @since 3.1.13
+ */
+public class ClassRelativeResourcePatternResolver extends PathMatchingResourcePatternResolver {
+
+    public ClassRelativeResourcePatternResolver(Class clazz) {
+        super(new ClassRelativeClassLoader(clazz));
+    }
+
+    @Override
+    protected void addAllClassLoaderJarRoots(ClassLoader classLoader, Set<Resource> result) {
+        // no-op - don't search jar roots
+    }
+}
diff --git a/grails-core/src/main/groovy/org/grails/spring/context/support/PluginAwareResourceBundleMessageSource.java b/grails-core/src/main/groovy/org/grails/spring/context/support/PluginAwareResourceBundleMessageSource.java
@@ -15,25 +15,29 @@
  */
 package org.grails.spring.context.support;
 
+import grails.core.DefaultGrailsApplication;
 import grails.core.GrailsApplication;
+import grails.core.GrailsApplicationClass;
 import grails.core.support.GrailsApplicationAware;
 import grails.plugins.GrailsPlugin;
 import grails.plugins.GrailsPluginManager;
 import grails.plugins.PluginManagerAware;
-import grails.util.*;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import grails.util.BuildSettings;
+import grails.util.CacheEntry;
+import grails.util.Environment;
+import grails.util.GrailsStringUtils;
 import org.grails.core.io.CachingPathMatchingResourcePatternResolver;
+import org.grails.core.support.internal.tools.ClassRelativeResourcePatternResolver;
 import org.grails.plugins.BinaryGrailsPlugin;
 import org.springframework.beans.factory.InitializingBean;
 import org.springframework.core.io.FileSystemResource;
 import org.springframework.core.io.Resource;
 import org.springframework.core.io.ResourceLoader;
 import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
+import org.springframework.core.io.support.ResourcePatternResolver;
 
 import java.io.File;
 import java.io.FilenameFilter;
-import java.io.IOException;
 import java.text.MessageFormat;
 import java.util.ArrayList;
 import java.util.List;
@@ -59,6 +63,8 @@ public class PluginAwareResourceBundleMessageSource extends ReloadableResourceBu
     private ConcurrentMap<Locale, CacheEntry<PropertiesHolder>> cachedMergedPluginProperties = new ConcurrentHashMap<Locale, CacheEntry<PropertiesHolder>>();
     private ConcurrentMap<Locale, CacheEntry<PropertiesHolder>> cachedMergedBinaryPluginProperties = new ConcurrentHashMap<Locale, CacheEntry<PropertiesHolder>>();
     private long pluginCacheMillis = Long.MIN_VALUE;
+    private boolean searchClasspath = false;
+    private String messageBundleLocationPattern = "classpath*:*.properties";
 
     @Deprecated
     public List<String> getPluginBaseNames() {
@@ -111,7 +117,20 @@ public boolean accept(File dir, String name) {
             }
         }
         else {
-            resources = resourceResolver.getResources("classpath*:**/*.properties");
+            if(searchClasspath) {
+                resources = resourceResolver.getResources(messageBundleLocationPattern);
+            }
+            else {
+                DefaultGrailsApplication defaultGrailsApplication = (DefaultGrailsApplication) application;
+                GrailsApplicationClass applicationClass = defaultGrailsApplication.getApplicationClass();
+                if(applicationClass != null) {
+                    ResourcePatternResolver resourcePatternResolver = new ClassRelativeResourcePatternResolver(applicationClass.getClass());
+                    resources = resourcePatternResolver.getResources(messageBundleLocationPattern);
+                }
+                else {
+                    resources = resourceResolver.getResources(messageBundleLocationPattern);
+                }
+            }
         }
 
         List<String> basenames = new ArrayList<String>();
@@ -261,5 +280,24 @@ public void setResourceLoader(ResourceLoader resourceLoader) {
      */
     public void setPluginCacheSeconds(int pluginCacheSeconds) {
         this.pluginCacheMillis = (pluginCacheSeconds * 1000);
-    }    
+    }
+
+    /**
+     * Whether to search the full classpath for message bundles. Enabling this will degrade startup performance.
+     * The default is to only search for message bundles relative to the application classes directory.
+     *
+     * @param searchClasspath True if the entire classpath should be searched
+     */
+    public void setSearchClasspath(boolean searchClasspath) {
+        this.searchClasspath = searchClasspath;
+    }
+
+    /**
+     * The location pattern for message bundles
+     *
+     * @param messageBundleLocationPattern The message bundle location pattern
+     */
+    public void setMessageBundleLocationPattern(String messageBundleLocationPattern) {
+        this.messageBundleLocationPattern = messageBundleLocationPattern;
+    }
 }
diff --git a/grails-core/src/test/groovy/org/grails/core/support/internal/tools/ClassRelativeClassLoaderSpec.groovy b/grails-core/src/test/groovy/org/grails/core/support/internal/tools/ClassRelativeClassLoaderSpec.groovy
@@ -0,0 +1,20 @@
+package org.grails.core.support.internal.tools
+
+import spock.lang.Specification
+
+/**
+ * Created by graemerocher on 30/09/2016.
+ */
+class ClassRelativeClassLoaderSpec extends Specification {
+
+    void "test class relative classloader"() {
+        when:"A classloader is created for only resources relative to this class"
+        def classLoader = new ClassRelativeClassLoader(ClassRelativeClassLoaderSpec)
+
+        then:"The resources are found"
+        classLoader.getResource('org/grails/core/support/internal/tools/ClassRelativeClassLoaderSpec.class')
+
+        and:"other classpath resources are not found"
+        !classLoader.getResource('springloaded.properties')
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -71,7 +71,7 @@ class GrailsApplicationPostProcessor implements BeanDefinitionRegistryPostProces`
`71`	`71`	`this.applicationClass = null`
`72`	`72`	`}`
`73`	`73`	`this.classes = classes != null ? classes : [] as Class[]`
`74`		`- grailsApplication = new DefaultGrailsApplication()`
	`74`	`+ grailsApplication = applicationClass != null ? new DefaultGrailsApplication(applicationClass) : new DefaultGrailsApplication()`
`75`	`75`	`pluginManager = new DefaultGrailsPluginManager(grailsApplication)`
`76`	`76`	`if(applicationContext != null) {`
`77`	`77`	`setApplicationContext(applicationContext)`