48031: Add support for multiple cache types (backends)

Author: elirenato

.github/native-tests.json

@@ -92,8 +92,8 @@
         },
         {
             "category": "Cache",
-            "timeout": 75,
-            "test-modules": "infinispan-cache-jpa, infinispan-client, cache, redis-cache, redis-devservices, infinispan-cache",
+            "timeout": 80,
+            "test-modules": "infinispan-cache-jpa, infinispan-client, cache, redis-cache, redis-devservices, infinispan-cache, cache-multiple-backends",
             "os-name": "ubuntu-latest"
         },
         {

docs/src/main/asciidoc/cache.adoc

@@ -771,6 +771,21 @@ The `setExpireAfterAccess`, `setExpireAfterWrite` and `setMaximumSize` methods f
 This extension uses https://github.com/ben-manes/caffeine[Caffeine] as its underlying caching provider.
 Caffeine is a high performance, near optimal caching library.
 
+== Multiple Backends Simultaneously
+
+This extension can be configured to use multiple backends simultaneously, allowing different caches to leverage either in-memory providers (like Caffeine) or distributed providers (like Redis) as needed, for example:
+
+[source,properties]
+----
+# default cache backend
+quarkus.cache.type=caffeine
+
+# change the cache backend for "weather-cache" to Redis.
+quarkus.cache.weather-cache.type=redis
+----
+
+NOTE: The syntax for the property name is `quarkus.cache."cache-name".type`. If no explicit backend is defined for a cache, the default backend is used. For details on configuring a specific backend, refer to its guide.
+
 === Caffeine configuration properties
 
 Each of the Caffeine caches backing up the Quarkus application data caching extension can be configured using the following

extensions/cache/runtime/src/main/java/io/quarkus/cache/runtime/CacheBuildConfig.java

@@ -2,9 +2,15 @@
 
 import static io.quarkus.runtime.annotations.ConfigPhase.BUILD_AND_RUN_TIME_FIXED;
 
+import java.util.Map;
+
+import io.quarkus.runtime.annotations.ConfigDocMapKey;
+import io.quarkus.runtime.annotations.ConfigDocSection;
+import io.quarkus.runtime.annotations.ConfigGroup;
 import io.quarkus.runtime.annotations.ConfigRoot;
 import io.smallrye.config.ConfigMapping;
 import io.smallrye.config.WithDefault;
+import io.smallrye.config.WithParentName;
 
 @ConfigRoot(phase = BUILD_AND_RUN_TIME_FIXED)
 @ConfigMapping(prefix = "quarkus.cache")
@@ -13,8 +19,29 @@ public interface CacheBuildConfig {
     String CAFFEINE_CACHE_TYPE = "caffeine";
 
     /**
-     * Cache type.
+     * Default cache type (backend provider). If no explicit type is defined for a cache, this type will be used.
      */
     @WithDefault(CAFFEINE_CACHE_TYPE)
     String type();
+
+    /**
+     * Configuration that allows customizing cache names to use a different type.
+     */
+    @ConfigDocMapKey("cache-name")
+    @ConfigDocSection
+    @WithParentName
+    Map<String, CacheTypeBuildConfig> cacheTypeByName();
+
+    /**
+     * Configuration that allows customizing cache names to use a different type.
+     */
+    @ConfigGroup
+    interface CacheTypeBuildConfig {
+
+        /**
+         * Cache type to be used for the cache name.
+         */
+        @WithDefault(CAFFEINE_CACHE_TYPE)
+        String type();
+    }
 }

extensions/cache/runtime/src/main/java/io/quarkus/cache/runtime/CacheManagerRecorder.java

@@ -3,11 +3,15 @@
 import static io.quarkus.cache.runtime.CacheBuildConfig.CAFFEINE_CACHE_TYPE;
 
 import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
 import java.util.Set;
 import java.util.function.Supplier;
 
 import jakarta.enterprise.inject.spi.DeploymentException;
 
+import io.quarkus.cache.Cache;
 import io.quarkus.cache.CacheManager;
 import io.quarkus.cache.CacheManagerInfo;
 import io.quarkus.cache.runtime.caffeine.CaffeineCacheManagerBuilder;
@@ -26,13 +30,15 @@ public CacheManagerRecorder(CacheBuildConfig cacheBuildConfig, RuntimeValue<Cach
         this.cacheConfigRV = cacheConfigRV;
     }
 
-    public Supplier<CacheManager> resolveCacheInfo(Collection<CacheManagerInfo> infos, Set<String> cacheNames,
+    private CacheManagerInfo.Context createContextForCacheType(
+            String cacheType,
             boolean micrometerMetricsEnabled) {
-        CacheConfig cacheConfig = cacheConfigRV.getValue();
-        CacheManagerInfo.Context context = new CacheManagerInfo.Context() {
+        return new CacheManagerInfo.Context() {
+            private final Set<String> cacheNames = new HashSet<>();
+
             @Override
             public boolean cacheEnabled() {
-                return cacheConfig.enabled();
+                return cacheConfigRV.getValue().enabled();
             }
 
             @Override
@@ -42,14 +48,36 @@ public Metrics metrics() {
 
             @Override
             public String cacheType() {
-                return cacheBuildConfig.type();
+                return cacheType;
             }
 
             @Override
             public Set<String> cacheNames() {
                 return cacheNames;
             }
         };
+    }
+
+    private Map<String, String> mapCacheTypeByCacheName(Set<String> cacheNames) {
+        Map<String, String> cacheTypeByName = new HashMap<>(cacheNames.size());
+        for (String cacheName : cacheNames) {
+            CacheBuildConfig.CacheTypeBuildConfig cacheTypeBuildConfig = cacheBuildConfig.cacheTypeByName().get(cacheName);
+            // check if the cache type is defined for this cache name "quarkus.cache.<cache-name>.type"
+            if (cacheTypeBuildConfig != null &&
+                    cacheTypeBuildConfig.type() != null &&
+                    !cacheTypeBuildConfig.type().isEmpty()) {
+                cacheTypeByName.put(cacheName, cacheTypeBuildConfig.type());
+            } else {
+                // if not, use the default cache type defined "quarkus.cache.type"
+                cacheTypeByName.put(cacheName, cacheBuildConfig.type());
+            }
+        }
+        return cacheTypeByName;
+    }
+
+    private Supplier<CacheManager> findSupplierForType(
+            CacheManagerInfo.Context context,
+            Collection<CacheManagerInfo> infos) {
         for (CacheManagerInfo info : infos) {
             if (info.supports(context)) {
                 return info.get(context);
@@ -58,6 +86,71 @@ public Set<String> cacheNames() {
         throw new DeploymentException("Unknown cache type: " + context.cacheType());
     }
 
+    private Map<String, Supplier<CacheManager>> createCacheSupplierByCacheType(
+            Collection<CacheManagerInfo> infos,
+            Set<String> cacheNames,
+            boolean micrometerMetricsEnabled) {
+
+        Map<String, String> cacheTypeByCacheName = mapCacheTypeByCacheName(cacheNames);
+
+        // create one context per cache type with their corresponding list of cache names
+        Map<String, CacheManagerInfo.Context> contextByCacheType = new HashMap<>();
+        for (String cacheName : cacheNames) {
+            contextByCacheType.computeIfAbsent(
+                    cacheTypeByCacheName.get(cacheName),
+                    cacheType -> this.createContextForCacheType(cacheType, micrometerMetricsEnabled))
+                    .cacheNames()
+                    .add(cacheName);
+        }
+
+        // suppliers grouped by cache type
+        Map<String, Supplier<CacheManager>> suppliersByType = new HashMap<>();
+        for (Map.Entry<String, CacheManagerInfo.Context> entry : contextByCacheType.entrySet()) {
+            String cacheType = entry.getKey();
+            if (!suppliersByType.containsKey(cacheType)) {
+                suppliersByType.put(cacheType, findSupplierForType(entry.getValue(), infos));
+            }
+        }
+
+        return suppliersByType;
+    }
+
+    public Supplier<CacheManager> resolveCacheInfo(
+            Collection<CacheManagerInfo> infos, Set<String> cacheNames,
+            boolean micrometerMetricsEnabled) {
+
+        Map<String, Supplier<CacheManager>> suppliersByType = createCacheSupplierByCacheType(
+                infos,
+                cacheNames,
+                micrometerMetricsEnabled);
+
+        return new Supplier<CacheManager>() {
+            @Override
+            public CacheManager get() {
+                if (suppliersByType.size() == 1) {
+                    // if there is only one cache type, return the corresponding cache implementation
+                    return suppliersByType.values().iterator().next().get();
+                }
+                // if there are multiple cache types, return a CacheManager implementation that aggregates all caches
+
+                // get the cache manager implementation by cache type of each supplier
+                Map<String, CacheManager> cacheImplByCacheType = new HashMap<>();
+                for (Map.Entry<String, Supplier<CacheManager>> entry : suppliersByType.entrySet()) {
+                    cacheImplByCacheType.put(entry.getKey(), entry.getValue().get());
+                }
+
+                // put all cache implementations together in a single map indexed by cache name
+                Map<String, Cache> allCaches = new HashMap<>();
+                for (CacheManager cacheManager : cacheImplByCacheType.values()) {
+                    for (String cacheName : cacheManager.getCacheNames()) {
+                        cacheManager.getCache(cacheName).ifPresent(cache -> allCaches.put(cacheName, cache));
+                    }
+                }
+                return new CacheManagerImpl(allCaches);
+            }
+        };
+    }
+
     public CacheManagerInfo noOpCacheManagerInfo() {
         return new CacheManagerInfo() {
             @Override