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

- AbstractNoSuchBeanDefinitionFailureAnalyzer - provides a basic implementation to inspect `not matches` auto-configurations and registered beans.

- AbstractNoUniqueBeanDefinitionFailureAnalyzer - provides a basic implementation to inspect registered beans.

Author: nosan

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

@@ -16,6 +16,8 @@
 
 package org.springframework.boot.autoconfigure.cache;
 
+import java.util.Map;
+import java.util.Set;
 import java.util.stream.Collectors;
 
 import org.springframework.beans.factory.InitializingBean;
@@ -42,7 +44,8 @@
 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;
+import org.springframework.util.StringUtils;
 
 /**
  * {@link EnableAutoConfiguration Auto-configuration} for the cache abstraction. Creates a
@@ -74,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
@@ -91,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);
+			}
 		}
 
 	}
@@ -133,4 +139,52 @@ 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) {
+			super(String.format("No qualifying bean of type '%s' available",
+					CacheManager.class.getName()));
+			this.properties = properties;
+		}
+
+		NoSuchCacheManagerException(String message, CacheProperties properties) {
+			super(message);
+			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(String.format(
+					"expected single matching bean of type '%s' but found " + "%d: %s",
+					CacheManager.class.getName(), beanNames.size(),
+					StringUtils.collectionToCommaDelimitedString(beanNames)), 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,72 @@
+/*
+ * 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.Collection;
+
+import org.springframework.beans.BeansException;
+import org.springframework.beans.factory.BeanFactory;
+import org.springframework.boot.autoconfigure.diagnostics.analyzer.NoSuchBeanDefinitionFailureAnalyzerSupport;
+import org.springframework.boot.diagnostics.AbstractFailureAnalyzer;
+import org.springframework.boot.diagnostics.FailureAnalysis;
+import org.springframework.boot.diagnostics.analyzer.NoUniqueBeanDefinitionFailureAnalyzerSupport;
+import org.springframework.cache.CacheManager;
+
+/**
+ * An {@link AbstractFailureAnalyzer} for
+ * {@link CacheAutoConfiguration.NoSuchCacheManagerException}.
+ *
+ * @author Dmytro Nosan
+ */
+class NoSuchCacheManagerFailureAnalyzer extends
+		NoSuchBeanDefinitionFailureAnalyzerSupport<CacheAutoConfiguration.NoSuchCacheManagerException> {
+
+	private final NoUniqueCacheManagerFailureAnalyzer analyzer = new NoUniqueCacheManagerFailureAnalyzer();
+
+	@Override
+	public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
+		super.setBeanFactory(beanFactory);
+		this.analyzer.setBeanFactory(beanFactory);
+	}
+
+	@Override
+	public FailureAnalysis analyze(Throwable failure) {
+		FailureAnalysis analyze = this.analyzer.analyze(failure);
+		if (analyze != null) {
+			return analyze;
+		}
+		return super.analyze(failure);
+	}
+
+	@Override
+	protected BeanMetadata getBeanMetadata(Throwable rootFailure,
+			CacheAutoConfiguration.NoSuchCacheManagerException cause) {
+		return new BeanMetadata(CacheManager.class);
+	}
+
+	private static final class NoUniqueCacheManagerFailureAnalyzer extends
+			NoUniqueBeanDefinitionFailureAnalyzerSupport<CacheAutoConfiguration.NoUniqueCacheManagerException> {
+
+		@Override
+		protected Collection<String> getBeanNames(Throwable rootFailure,
+				CacheAutoConfiguration.NoUniqueCacheManagerException cause) {
+			return cause.getBeanNames();
+		}
+
+	}
+
+}