From d0fd6145b1f3072bcc5ad81f7c20e80e890b9442 Mon Sep 17 00:00:00 2001 From: Phillip Webb Date: Tue, 9 Jun 2015 17:07:30 -0700 Subject: [PATCH] Fix CacheType outer class tangle Fixes gh-3168 --- .../cache/CacheAutoConfiguration.java | 2 +- .../autoconfigure/cache/CacheCondition.java | 4 +- .../cache/CacheConfigurations.java | 63 +++++++++++++++++++ .../boot/autoconfigure/cache/CacheType.java | 37 +++-------- 4 files changed, 75 insertions(+), 31 deletions(-) create mode 100644 spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/cache/CacheConfigurations.java diff --git a/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/cache/CacheAutoConfiguration.java b/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/cache/CacheAutoConfiguration.java index 97119c93f22..6509fd762ed 100644 --- a/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/cache/CacheAutoConfiguration.java +++ b/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/cache/CacheAutoConfiguration.java @@ -131,7 +131,7 @@ public class CacheAutoConfiguration { CacheType[] types = CacheType.values(); String[] imports = new String[types.length]; for (int i = 0; i < types.length; i++) { - imports[i] = types[i].getConfigurationClass().getName(); + imports[i] = CacheConfigurations.getConfigurationClass(types[i]); } return imports; } diff --git a/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/cache/CacheCondition.java b/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/cache/CacheCondition.java index 77cdd4a5ce0..e785ac9cb23 100644 --- a/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/cache/CacheCondition.java +++ b/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/cache/CacheCondition.java @@ -40,8 +40,8 @@ class CacheCondition extends SpringBootCondition { if (!resolver.containsProperty("type")) { return ConditionOutcome.match("Automatic cache type"); } - CacheType cacheType = CacheType - .forConfigurationClass(((AnnotationMetadata) metadata).getClassName()); + CacheType cacheType = CacheConfigurations.getType(((AnnotationMetadata) metadata) + .getClassName()); String value = resolver.getProperty("type").replace("-", "_").toUpperCase(); if (value.equals(cacheType.name())) { return ConditionOutcome.match("Cache type " + cacheType); diff --git a/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/cache/CacheConfigurations.java b/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/cache/CacheConfigurations.java new file mode 100644 index 00000000000..3f404bd3c2a --- /dev/null +++ b/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/cache/CacheConfigurations.java @@ -0,0 +1,63 @@ +/* + * Copyright 2012-2015 the original author or authors. + * + * Licensed 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 + * + * http://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.springframework.boot.autoconfigure.cache; + +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; + +import org.springframework.util.Assert; + +/** + * Mappings between {@link CacheType} and {@code @Configuration}. + * + * @author Phillip Webb + */ +class CacheConfigurations { + + private static final Map> MAPPINGS; + static { + Map> mappings = new HashMap>(); + mappings.put(CacheType.GENERIC, GenericCacheConfiguration.class); + mappings.put(CacheType.EHCACHE, EhCacheCacheConfiguration.class); + mappings.put(CacheType.HAZELCAST, HazelcastCacheConfiguration.class); + mappings.put(CacheType.INFINISPAN, InfinispanCacheConfiguration.class); + mappings.put(CacheType.JCACHE, JCacheCacheConfiguration.class); + mappings.put(CacheType.REDIS, RedisCacheConfiguration.class); + mappings.put(CacheType.GUAVA, GuavaCacheConfiguration.class); + mappings.put(CacheType.SIMPLE, SimpleCacheConfiguration.class); + mappings.put(CacheType.NONE, NoOpCacheConfiguration.class); + MAPPINGS = Collections.unmodifiableMap(mappings); + } + + public static String getConfigurationClass(CacheType cacheType) { + Class configurationClass = MAPPINGS.get(cacheType); + Assert.state(configurationClass != null, "Unknown cache type " + cacheType); + return configurationClass.getName(); + } + + public static CacheType getType(String configurationClassName) { + for (Map.Entry> entry : MAPPINGS.entrySet()) { + if (entry.getValue().getName().equals(configurationClassName)) { + return entry.getKey(); + } + } + throw new IllegalStateException("Unknown configuration class " + + configurationClassName); + } + +} diff --git a/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/cache/CacheType.java b/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/cache/CacheType.java index 508fe4411be..c9e3ae7b425 100644 --- a/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/cache/CacheType.java +++ b/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/cache/CacheType.java @@ -29,65 +29,46 @@ public enum CacheType { /** * Generic caching using 'Cache' beans from the context. */ - GENERIC(GenericCacheConfiguration.class), + GENERIC, /** * EhCache backed caching. */ - EHCACHE(EhCacheCacheConfiguration.class), + EHCACHE, /** * Hazelcast backed caching */ - HAZELCAST(HazelcastCacheConfiguration.class), + HAZELCAST, /** * Infinispan backed caching. */ - INFINISPAN(InfinispanCacheConfiguration.class), + INFINISPAN, /** * JCache (JSR-107) backed caching. */ - JCACHE(JCacheCacheConfiguration.class), + JCACHE, /** * Redis backed caching. */ - REDIS(RedisCacheConfiguration.class), + REDIS, /** * Guava backed caching. */ - GUAVA(GuavaCacheConfiguration.class), + GUAVA, /** * Simple in-memory caching. */ - SIMPLE(SimpleCacheConfiguration.class), + SIMPLE, /** * No caching. */ - NONE(NoOpCacheConfiguration.class); - - private final Class configurationClass; - - CacheType(Class configurationClass) { - this.configurationClass = configurationClass; - } - - Class getConfigurationClass() { - return this.configurationClass; - } - - static CacheType forConfigurationClass(String configurationClass) { - for (CacheType type : values()) { - if (type.getConfigurationClass().getName().equals(configurationClass)) { - return type; - } - } - throw new IllegalArgumentException("Unsupported class " + configurationClass); - } + NONE; }