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

- AbstractNoSuchBeanDefinitionFailureAnalyzer.

Author: nosan

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

@@ -17,6 +17,8 @@
 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.ObjectProvider;
@@ -43,7 +45,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 +77,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 +95,29 @@ 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 NoUniqueCacheManagerException(this.cacheManagers.keySet(),
+						this.cacheProperties);
+			}
 		}
 
 	}
@@ -134,4 +139,42 @@ public String[] selectImports(AnnotationMetadata importingClassMetadata) {
 
 	}
 
+	/**
+	 * Exception thrown when {@link org.springframework.cache.CacheManager} implementation
+	 * are not specified.
+	 */
+	static class NoSuchCacheManagerException extends RuntimeException {
+
+		private final CacheProperties properties;
+
+		NoSuchCacheManagerException(CacheProperties properties) {
+			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 NoUniqueCacheManagerException extends NoSuchCacheManagerException {
+
+		private final Set<String> beanNames;
+
+		NoUniqueCacheManagerException(Set<String> beanNames, CacheProperties properties) {
+			super(properties);
+			this.beanNames = beanNames;
+		}
+
+		Set<String> getBeanNames() {
+			return this.beanNames;
+		}
+
+	}
+
 }

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

@@ -0,0 +1,104 @@
+/*
+ * 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 java.util.Set;
+
+import org.springframework.beans.BeansException;
+import org.springframework.beans.factory.BeanFactory;
+import org.springframework.beans.factory.NoSuchBeanDefinitionException;
+import org.springframework.beans.factory.config.BeanDefinition;
+import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
+import org.springframework.boot.autoconfigure.diagnostics.analyzer.NoSuchBeanDefinitionFailureAnalyzerSupport;
+import org.springframework.boot.diagnostics.AbstractFailureAnalyzer;
+import org.springframework.boot.diagnostics.FailureAnalysis;
+import org.springframework.cache.CacheManager;
+import org.springframework.util.Assert;
+import org.springframework.util.CollectionUtils;
+import org.springframework.util.StringUtils;
+
+/**
+ * An {@link AbstractFailureAnalyzer} for
+ * {@link CacheAutoConfiguration.NoSuchCacheManagerException}.
+ *
+ * @author Dmytro Nosan
+ */
+class NoSuchCacheManagerFailureAnalyzer extends
+		NoSuchBeanDefinitionFailureAnalyzerSupport<CacheAutoConfiguration.NoSuchCacheManagerException> {
+
+	private ConfigurableListableBeanFactory beanFactory;
+
+	@Override
+	public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
+		Assert.isInstanceOf(ConfigurableListableBeanFactory.class, beanFactory);
+		this.beanFactory = (ConfigurableListableBeanFactory) beanFactory;
+		super.setBeanFactory(beanFactory);
+	}
+
+	@Override
+	public FailureAnalysis analyze(Throwable failure) {
+		CacheAutoConfiguration.NoUniqueCacheManagerException cause = findCause(failure,
+				CacheAutoConfiguration.NoUniqueCacheManagerException.class);
+		if (cause != null) {
+			return analyzeNoUniqueCacheManagerException(cause);
+		}
+		return super.analyze(failure);
+	}
+
+	@Override
+	protected BeanMetadata getBeanMetadata(Throwable rootFailure,
+			CacheAutoConfiguration.NoSuchCacheManagerException cause) {
+		return new BeanMetadata(CacheManager.class);
+	}
+
+	private FailureAnalysis analyzeNoUniqueCacheManagerException(
+			CacheAutoConfiguration.NoUniqueCacheManagerException cause) {
+		Set<String> beanNames = cause.getBeanNames();
+		if (CollectionUtils.isEmpty(beanNames)) {
+			return null;
+		}
+		StringBuilder description = new StringBuilder();
+		description.append(String.format("Found %d beans of the type " + "'%s'%n",
+				beanNames.size(), CacheManager.class.getName()));
+		for (String beanName : beanNames) {
+			try {
+				BeanDefinition definition = this.beanFactory
+						.getMergedBeanDefinition(beanName);
+				if (StringUtils.hasText(definition.getFactoryMethodName())) {
+					description.append(
+							String.format("\t- '%s': defined by method '%s' in %s%n",
+									beanName, definition.getFactoryMethodName(),
+									definition.getResourceDescription()));
+				}
+				else {
+					description.append(String.format("\t- '%s': defined in %s%n",
+							beanName, definition.getResourceDescription()));
+				}
+			}
+			catch (NoSuchBeanDefinitionException ex) {
+				description.append(String.format(
+						"\t- '%s': a programmatically registered singleton", beanName));
+			}
+		}
+		return new FailureAnalysis(description.toString(),
+				"Consider marking one of the beans as @Primary, updating the consumer to"
+						+ " accept multiple beans, or using @Qualifier to identify the"
+						+ " bean that should be consumed",
+				cause);
+	}
+
+}