From 6f1acdd561e60b389fa2eefdecf1f2811018253d Mon Sep 17 00:00:00 2001 From: Stephane Nicoll Date: Tue, 30 Sep 2014 17:59:52 +0200 Subject: [PATCH] Optimize ResolvableType cache Prior to this commit, the ResolvableType static cache was holding a lot of duplicates for simple types. We are using too much metadata to compute the key when the class has no generic information. so setFoo(String foo) and setBar(String bar) would result in two entries in the cache because the TypeProvider is different. On a very simple application 65% of the entries in the cache were duplicate. When the type is a Class with no generic information, the ResolvableType instance is a simple wrapper around it so we might just as well not cache it at all as the cost of finding it back from the cache is higher than creating that simple wrapper. This commit adds an explicit check; if the type is a simple Class we just return a "resolved" ResolvableType instance for it. On a few test cases, this reduces the size of the cache by 85% Issue: SPR-12275 --- .../main/java/org/springframework/core/ResolvableType.java | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/spring-core/src/main/java/org/springframework/core/ResolvableType.java b/spring-core/src/main/java/org/springframework/core/ResolvableType.java index 6948d9ab61..16cd8c4792 100644 --- a/spring-core/src/main/java/org/springframework/core/ResolvableType.java +++ b/spring-core/src/main/java/org/springframework/core/ResolvableType.java @@ -1194,6 +1194,10 @@ public final class ResolvableType implements Serializable { } // Check the cache, we may have a ResolvableType that may have already been resolved cache.purgeUnreferencedEntries(); + + if (type instanceof Class) { + return new ResolvableType(type, typeProvider, variableResolver, null); + } ResolvableType key = new ResolvableType(type, typeProvider, variableResolver); ResolvableType resolvableType = cache.get(key); if (resolvableType == null) { -- GitLab