- NoSuchCacheManagerFailureAnalyzer - analyzer for 'CacheManager' is not found.

Author: nosan

spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/cache/CacheAutoConfiguration.java

@@ -17,8 +17,12 @@
 package org.springframework.boot.autoconfigure.cache;
 
 import java.util.List;
+import java.util.Map;
+import java.util.Set;
 
 import org.springframework.beans.factory.InitializingBean;
+import org.springframework.beans.factory.NoSuchBeanDefinitionException;
+import org.springframework.beans.factory.NoUniqueBeanDefinitionException;
 import org.springframework.beans.factory.ObjectProvider;
 import org.springframework.boot.autoconfigure.AutoConfigureAfter;
 import org.springframework.boot.autoconfigure.AutoConfigureBefore;
@@ -43,7 +47,7 @@
 import org.springframework.core.type.AnnotationMetadata;
 import org.springframework.orm.jpa.AbstractEntityManagerFactoryBean;
 import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
-import org.springframework.util.Assert;
+import org.springframework.util.CollectionUtils;
 
 /**
  * {@link EnableAutoConfiguration Auto-configuration} for the cache abstraction. Creates a
@@ -75,8 +79,9 @@ public CacheManagerCustomizers cacheManagerCustomizers(
 
 	@Bean
 	public CacheManagerValidator cacheAutoConfigurationValidator(
-			CacheProperties cacheProperties, ObjectProvider<CacheManager> cacheManager) {
-		return new CacheManagerValidator(cacheProperties, cacheManager);
+			CacheProperties cacheProperties,
+			ObjectProvider<Map<String, CacheManager>> cacheManagers) {
+		return new CacheManagerValidator(cacheProperties, cacheManagers);
 	}
 
 	@Configuration
@@ -92,27 +97,28 @@ public CacheManagerJpaDependencyConfiguration() {
 	}
 
 	/**
-	 * Bean used to validate that a CacheManager exists and provide a more meaningful
-	 * exception.
+	 * Bean used to validate that a CacheManager exists and it unique.
 	 */
 	static class CacheManagerValidator implements InitializingBean {
 
 		private final CacheProperties cacheProperties;
 
-		private final ObjectProvider<CacheManager> cacheManager;
+		private final Map<String, CacheManager> cacheManagers;
 
 		CacheManagerValidator(CacheProperties cacheProperties,
-				ObjectProvider<CacheManager> cacheManager) {
+				ObjectProvider<Map<String, CacheManager>> cacheManagers) {
 			this.cacheProperties = cacheProperties;
-			this.cacheManager = cacheManager;
+			this.cacheManagers = cacheManagers.getIfAvailable();
 		}
 
 		@Override
 		public void afterPropertiesSet() {
-			Assert.notNull(this.cacheManager.getIfAvailable(),
-					() -> "No cache manager could "
-							+ "be auto-configured, check your configuration (caching "
-							+ "type is '" + this.cacheProperties.getType() + "')");
+			if (CollectionUtils.isEmpty(this.cacheManagers)) {
+				throw new NoSuchCacheManagerException(this.cacheProperties);
+			}
+			if (this.cacheManagers.size() > 1) {
+				throw new NonUniqueCacheManagerException(this.cacheManagers.keySet());
+			}
 		}
 
 	}
@@ -134,4 +140,37 @@ public String[] selectImports(AnnotationMetadata importingClassMetadata) {
 
 	}
 
+	/**
+	 * Exception thrown when {@link org.springframework.cache.CacheManager} implementation
+	 * are not specified.
+	 */
+	static class NoSuchCacheManagerException extends NoSuchBeanDefinitionException {
+
+		private final CacheProperties properties;
+
+		NoSuchCacheManagerException(CacheProperties properties) {
+			super("No cache manager could be auto-configured, check your configuration"
+					+ " (caching type is '" + properties.getType() + "')");
+			this.properties = properties;
+		}
+
+		CacheProperties getProperties() {
+			return this.properties;
+		}
+
+	}
+
+	/**
+	 * Exception thrown when multiple {@link org.springframework.cache.CacheManager}
+	 * implementations are available with no way to know which implementation should be
+	 * used.
+	 */
+	static class NonUniqueCacheManagerException extends NoUniqueBeanDefinitionException {
+
+		NonUniqueCacheManagerException(Set<String> beans) {
+			super(CacheManager.class, beans);
+		}
+
+	}
+
 }

spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/cache/NoSuchCacheManagerFailureAnalyzer.java

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2012-2018 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 org.springframework.boot.diagnostics.AbstractFailureAnalyzer;
+import org.springframework.boot.diagnostics.FailureAnalysis;
+
+/**
+ * An {@link AbstractFailureAnalyzer} for
+ * {@link CacheAutoConfiguration.NoSuchCacheManagerException}.
+ *
+ * @author Dmytro Nosan
+ * @since 2.1.0
+ */
+class NoSuchCacheManagerFailureAnalyzer extends
+		AbstractFailureAnalyzer<CacheAutoConfiguration.NoSuchCacheManagerException> {
+
+	@Override
+	protected FailureAnalysis analyze(Throwable rootFailure,
+			CacheAutoConfiguration.NoSuchCacheManagerException cause) {
+		CacheProperties cacheProperties = cause.getProperties();
+		if (cacheProperties.getType() == CacheType.GENERIC) {
+			String description = String
+					.format("No 'CacheManager' could be auto-configured.%n");
+			String action = String.format("'spring.cache.type=generic' "
+					+ "property was used, it requires that one or more 'Cache' bean(s) "
+					+ "must be specified.%n");
+			return new FailureAnalysis(description, action, cause);
+		}
+		return null;
+	}
+
+}

spring-boot-project/spring-boot-autoconfigure/src/main/resources/META-INF/spring.factories

@@ -134,7 +134,8 @@ org.springframework.boot.diagnostics.FailureAnalyzer=\
 org.springframework.boot.autoconfigure.diagnostics.analyzer.NoSuchBeanDefinitionFailureAnalyzer,\
 org.springframework.boot.autoconfigure.jdbc.DataSourceBeanCreationFailureAnalyzer,\
 org.springframework.boot.autoconfigure.jdbc.HikariDriverConfigurationFailureAnalyzer,\
-org.springframework.boot.autoconfigure.session.NonUniqueSessionRepositoryFailureAnalyzer
+org.springframework.boot.autoconfigure.session.NonUniqueSessionRepositoryFailureAnalyzer,\
+org.springframework.boot.autoconfigure.cache.NoSuchCacheManagerFailureAnalyzer
 
 # Template availability providers
 org.springframework.boot.autoconfigure.template.TemplateAvailabilityProvider=\

spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/cache/CacheAutoConfigurationTests.java

@@ -170,6 +170,16 @@ public void simpleCacheExplicitWithCacheNames() {
 				});
 	}
 
+	@Test
+	public void multiplyCacheManagers() {
+		this.contextRunner.withUserConfiguration(DefaultCacheConfiguration.class)
+				.withConfiguration(AutoConfigurations.of(CacheManagerConfiguration.class))
+				.withPropertyValues("spring.cache.type=simple")
+				.run((context) -> assertThat(context).getFailure()
+						.isInstanceOf(BeanCreationException.class).hasMessageContaining(
+								"No qualifying bean of type 'org.springframework.cache.CacheManager'"));
+	}
+
 	@Test
 	public void genericCacheWithCaches() {
 		this.contextRunner.withUserConfiguration(GenericCacheConfiguration.class)
@@ -804,6 +814,16 @@ static class DefaultCacheAndCustomizersConfiguration {
 
 	}
 
+	@Configuration
+	static class CacheManagerConfiguration {
+
+		@Bean
+		public CacheManager customCacheManager() {
+			return new SimpleCacheManager();
+		}
+
+	}
+
 	@Configuration
 	@EnableCaching
 	static class GenericCacheConfiguration {

spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/cache/NoSuchCacheManagerFailureAnalyzerTests.java

@@ -0,0 +1,93 @@
+/*
+ * Copyright 2012-2018 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 org.junit.Test;
+
+import org.springframework.beans.factory.BeanCreationException;
+import org.springframework.boot.autoconfigure.ImportAutoConfiguration;
+import org.springframework.boot.diagnostics.FailureAnalysis;
+import org.springframework.boot.diagnostics.LoggingFailureAnalysisReporter;
+import org.springframework.boot.test.util.TestPropertyValues;
+import org.springframework.cache.annotation.EnableCaching;
+import org.springframework.context.annotation.AnnotationConfigApplicationContext;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Import;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Tests for {@link NoSuchCacheManagerFailureAnalyzer}.
+ *
+ * @author Dmytro Nosan
+ */
+public class NoSuchCacheManagerFailureAnalyzerTests {
+
+	private final NoSuchCacheManagerFailureAnalyzer analyzer = new NoSuchCacheManagerFailureAnalyzer();
+
+	@Test
+	public void failureAnalysisForNoCacheManagers() {
+		assertThat(analyzeFailure(createFailure(DefaultCacheAutoConfiguration.class,
+				"spring.cache.type=jcache"))).isNull();
+	}
+
+	@Test
+	public void failureAnalysisForGenericCacheType() {
+		FailureAnalysis analysis = analyzeFailure(createFailure(
+				DefaultCacheAutoConfiguration.class, "spring.cache.type=generic"));
+		assertThat(analysis.getAction())
+				.contains("'spring.cache.type=generic' property was used")
+				.doesNotContain("Check your configuration");
+		assertThat(analysis.getDescription())
+				.contains("No 'CacheManager' could be auto-configured.");
+
+	}
+
+	private BeanCreationException createFailure(Class<?> config, String... environment) {
+		try (AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext()) {
+			TestPropertyValues.of(environment).applyTo(context);
+			context.register(config);
+			context.refresh();
+			return null;
+		}
+		catch (BeanCreationException ex) {
+			return ex;
+		}
+	}
+
+	private FailureAnalysis analyzeFailure(Exception failure) {
+		FailureAnalysis analysis = this.analyzer.analyze(failure);
+		if (analysis != null) {
+			new LoggingFailureAnalysisReporter().report(analysis);
+		}
+		return analysis;
+	}
+
+	@EnableCaching
+	@Configuration
+	static class DefaultCacheConfiguration {
+
+	}
+
+	@Configuration
+	@ImportAutoConfiguration(CacheAutoConfiguration.class)
+	@Import(DefaultCacheConfiguration.class)
+	static class DefaultCacheAutoConfiguration {
+
+	}
+
+}