diff --git a/extensions/cache/deployment/src/main/java/io/quarkus/cache/deployment/CacheConfig.java b/extensions/cache/deployment/src/main/java/io/quarkus/cache/deployment/CacheConfig.java
index b07e242a00e1a..fa87ec3073a9d 100644
--- a/extensions/cache/deployment/src/main/java/io/quarkus/cache/deployment/CacheConfig.java
+++ b/extensions/cache/deployment/src/main/java/io/quarkus/cache/deployment/CacheConfig.java
@@ -15,8 +15,7 @@
 public class CacheConfig {
 
     /**
-     * Whether or not the cache extension is enabled. If the extension is disabled, the caching annotations will have no effect
-     * at run time.
+     * Whether or not the cache extension is enabled.
      */
     @ConfigItem(defaultValue = "true")
     public boolean enabled;
diff --git a/extensions/cache/deployment/src/main/java/io/quarkus/cache/deployment/CacheDeploymentConstants.java b/extensions/cache/deployment/src/main/java/io/quarkus/cache/deployment/CacheDeploymentConstants.java
index 0116dadc22830..030b0208bd5dd 100644
--- a/extensions/cache/deployment/src/main/java/io/quarkus/cache/deployment/CacheDeploymentConstants.java
+++ b/extensions/cache/deployment/src/main/java/io/quarkus/cache/deployment/CacheDeploymentConstants.java
@@ -8,11 +8,13 @@
 import io.quarkus.cache.CacheInvalidate;
 import io.quarkus.cache.CacheInvalidateAll;
 import io.quarkus.cache.CacheKey;
+import io.quarkus.cache.CacheName;
 import io.quarkus.cache.CacheResult;
 
 public class CacheDeploymentConstants {
 
     // API annotations names.
+    public static final DotName CACHE_NAME = dotName(CacheName.class);
     public static final DotName CACHE_INVALIDATE_ALL = dotName(CacheInvalidateAll.class);
     public static final DotName CACHE_INVALIDATE_ALL_LIST = dotName(CacheInvalidateAll.List.class);
     public static final DotName CACHE_INVALIDATE = dotName(CacheInvalidate.class);
diff --git a/extensions/cache/deployment/src/main/java/io/quarkus/cache/deployment/CacheProcessor.java b/extensions/cache/deployment/src/main/java/io/quarkus/cache/deployment/CacheProcessor.java
index ff6e12e34157f..694f963852709 100644
--- a/extensions/cache/deployment/src/main/java/io/quarkus/cache/deployment/CacheProcessor.java
+++ b/extensions/cache/deployment/src/main/java/io/quarkus/cache/deployment/CacheProcessor.java
@@ -2,6 +2,7 @@
 
 import static io.quarkus.cache.deployment.CacheDeploymentConstants.API_METHODS_ANNOTATIONS;
 import static io.quarkus.cache.deployment.CacheDeploymentConstants.API_METHODS_ANNOTATIONS_LISTS;
+import static io.quarkus.cache.deployment.CacheDeploymentConstants.CACHE_NAME;
 import static io.quarkus.cache.deployment.CacheDeploymentConstants.CACHE_NAME_PARAM;
 import static io.quarkus.deployment.annotations.ExecutionTime.STATIC_INIT;
 import static org.jboss.jandex.AnnotationTarget.Kind.METHOD;
@@ -11,17 +12,19 @@
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
-import java.util.function.BooleanSupplier;
 
 import javax.enterprise.inject.spi.DeploymentException;
 
 import org.jboss.jandex.AnnotationInstance;
+import org.jboss.jandex.AnnotationTarget;
+import org.jboss.jandex.AnnotationTarget.Kind;
 import org.jboss.jandex.DotName;
 import org.jboss.jandex.IndexView;
 import org.jboss.jandex.MethodInfo;
 
 import io.quarkus.arc.deployment.AdditionalBeanBuildItem;
 import io.quarkus.arc.deployment.AnnotationsTransformerBuildItem;
+import io.quarkus.arc.deployment.AutoInjectAnnotationBuildItem;
 import io.quarkus.arc.deployment.BeanContainerBuildItem;
 import io.quarkus.arc.deployment.ValidationPhaseBuildItem;
 import io.quarkus.arc.deployment.ValidationPhaseBuildItem.ValidationErrorBuildItem;
@@ -33,6 +36,7 @@
 import io.quarkus.cache.runtime.CacheResultInterceptor;
 import io.quarkus.cache.runtime.caffeine.CaffeineCacheBuildRecorder;
 import io.quarkus.cache.runtime.caffeine.CaffeineCacheInfo;
+import io.quarkus.cache.runtime.noop.NoOpCacheBuildRecorder;
 import io.quarkus.deployment.Feature;
 import io.quarkus.deployment.annotations.BuildStep;
 import io.quarkus.deployment.annotations.Record;
@@ -46,12 +50,17 @@ FeatureBuildItem feature() {
         return new FeatureBuildItem(Feature.CACHE);
     }
 
-    @BuildStep(onlyIf = CacheEnabled.class)
+    @BuildStep
+    AutoInjectAnnotationBuildItem autoInjectCacheName() {
+        return new AutoInjectAnnotationBuildItem(CACHE_NAME);
+    }
+
+    @BuildStep
     AnnotationsTransformerBuildItem annotationsTransformer() {
         return new AnnotationsTransformerBuildItem(new CacheAnnotationsTransformer());
     }
 
-    @BuildStep(onlyIf = CacheEnabled.class)
+    @BuildStep
     List<AdditionalBeanBuildItem> additionalBeans() {
         return Arrays.asList(
                 new AdditionalBeanBuildItem(CacheInvalidateAllInterceptor.class),
@@ -59,7 +68,7 @@ List<AdditionalBeanBuildItem> additionalBeans() {
                 new AdditionalBeanBuildItem(CacheResultInterceptor.class));
     }
 
-    @BuildStep(onlyIf = CacheEnabled.class)
+    @BuildStep
     ValidationErrorBuildItem validateBeanDeployment(ValidationPhaseBuildItem validationPhase) {
         AnnotationStore annotationStore = validationPhase.getContext().get(Key.ANNOTATION_STORE);
         List<Throwable> throwables = new ArrayList<>();
@@ -75,26 +84,30 @@ ValidationErrorBuildItem validateBeanDeployment(ValidationPhaseBuildItem validat
         return new ValidationErrorBuildItem(throwables.toArray(new Throwable[0]));
     }
 
-    @BuildStep(onlyIf = CacheEnabled.class)
+    @BuildStep
     @Record(STATIC_INIT)
     void recordCachesBuild(CombinedIndexBuildItem combinedIndex, BeanContainerBuildItem beanContainer, CacheConfig config,
-            CaffeineCacheBuildRecorder caffeineRecorder,
+            CaffeineCacheBuildRecorder caffeineRecorder, NoOpCacheBuildRecorder noOpRecorder,
             List<AdditionalCacheNameBuildItem> additionalCacheNames) {
-        Set<String> cacheNames = getCacheNames(combinedIndex.getIndex());
-        for (AdditionalCacheNameBuildItem additionalCacheName : additionalCacheNames) {
-            cacheNames.add(additionalCacheName.getName());
-        }
-        switch (config.type) {
-            case CacheDeploymentConstants.CAFFEINE_CACHE_TYPE:
-                Set<CaffeineCacheInfo> cacheInfos = CaffeineCacheInfoBuilder.build(cacheNames, config);
-                caffeineRecorder.buildCaches(beanContainer.getValue(), cacheInfos);
-                break;
-            default:
-                throw new DeploymentException("Unknown cache type: " + config.type);
+        Set<String> cacheNames = getCacheNames(combinedIndex.getIndex(), additionalCacheNames);
+        validateCacheNameAnnotations(combinedIndex.getIndex(), cacheNames);
+        if (cacheNames.size() > 0) {
+            if (config.enabled) {
+                switch (config.type) {
+                    case CacheDeploymentConstants.CAFFEINE_CACHE_TYPE:
+                        Set<CaffeineCacheInfo> cacheInfos = CaffeineCacheInfoBuilder.build(cacheNames, config);
+                        caffeineRecorder.buildCaches(beanContainer.getValue(), cacheInfos);
+                        break;
+                    default:
+                        throw new DeploymentException("Unknown cache type: " + config.type);
+                }
+            } else {
+                noOpRecorder.buildCaches(beanContainer.getValue(), cacheNames);
+            }
         }
     }
 
-    private Set<String> getCacheNames(IndexView index) {
+    private Set<String> getCacheNames(IndexView index, List<AdditionalCacheNameBuildItem> additionalCacheNames) {
         Set<String> cacheNames = new HashSet<>();
         for (DotName cacheAnnotation : API_METHODS_ANNOTATIONS) {
             for (AnnotationInstance annotation : index.getAnnotations(cacheAnnotation)) {
@@ -112,15 +125,29 @@ private Set<String> getCacheNames(IndexView index) {
                 }
             }
         }
+        for (AdditionalCacheNameBuildItem additionalCacheName : additionalCacheNames) {
+            cacheNames.add(additionalCacheName.getName());
+        }
         return cacheNames;
     }
 
-    private static class CacheEnabled implements BooleanSupplier {
-
-        CacheConfig config;
-
-        public boolean getAsBoolean() {
-            return config.enabled;
+    private void validateCacheNameAnnotations(IndexView index, Set<String> cacheNames) {
+        for (AnnotationInstance cacheNameAnnotation : index.getAnnotations(CACHE_NAME)) {
+            AnnotationTarget target = cacheNameAnnotation.target();
+            if (target.kind() == Kind.FIELD || target.kind() == Kind.METHOD_PARAMETER) {
+                String cacheName = cacheNameAnnotation.value().asString();
+                if (!cacheNames.contains(cacheName)) {
+                    String declaringClass;
+                    if (target.kind() == Kind.FIELD) {
+                        declaringClass = target.asField().declaringClass().name().toString();
+                    } else {
+                        declaringClass = target.asMethodParameter().method().declaringClass().name().toString();
+                    }
+                    throw new DeploymentException(
+                            "A field or method parameter is annotated with @CacheName(\"" + cacheName + "\") in the "
+                                    + declaringClass + " class but there is no cache with this name in the application");
+                }
+            }
         }
     }
 }
diff --git a/extensions/cache/deployment/src/test/java/io/quarkus/cache/test/deployment/CacheConfigTest.java b/extensions/cache/deployment/src/test/java/io/quarkus/cache/test/deployment/CacheConfigTest.java
index d2cfac8cd281f..013daa0dd8b94 100644
--- a/extensions/cache/deployment/src/test/java/io/quarkus/cache/test/deployment/CacheConfigTest.java
+++ b/extensions/cache/deployment/src/test/java/io/quarkus/cache/test/deployment/CacheConfigTest.java
@@ -13,8 +13,8 @@
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.RegisterExtension;
 
+import io.quarkus.cache.CacheManager;
 import io.quarkus.cache.CacheResult;
-import io.quarkus.cache.runtime.CacheRepository;
 import io.quarkus.cache.runtime.caffeine.CaffeineCache;
 import io.quarkus.test.QuarkusUnitTest;
 
@@ -29,11 +29,11 @@ public class CacheConfigTest {
     private static final String CACHE_NAME = "test-cache";
 
     @Inject
-    CacheRepository cacheRepository;
+    CacheManager cacheManager;
 
     @Test
     public void testConfig() {
-        CaffeineCache cache = (CaffeineCache) cacheRepository.getCache(CACHE_NAME);
+        CaffeineCache cache = (CaffeineCache) cacheManager.getCache(CACHE_NAME).get();
         assertEquals(10, cache.getInitialCapacity());
         assertEquals(100L, cache.getMaximumSize());
         assertEquals(Duration.ofSeconds(30L), cache.getExpireAfterWrite());
diff --git a/extensions/cache/deployment/src/test/java/io/quarkus/cache/test/deployment/UnknownCacheTypeTest.java b/extensions/cache/deployment/src/test/java/io/quarkus/cache/test/deployment/UnknownCacheTypeTest.java
index e45781af4745f..3beff50967f1e 100644
--- a/extensions/cache/deployment/src/test/java/io/quarkus/cache/test/deployment/UnknownCacheTypeTest.java
+++ b/extensions/cache/deployment/src/test/java/io/quarkus/cache/test/deployment/UnknownCacheTypeTest.java
@@ -2,6 +2,7 @@
 
 import static org.junit.jupiter.api.Assertions.fail;
 
+import javax.enterprise.context.ApplicationScoped;
 import javax.enterprise.inject.spi.DeploymentException;
 
 import org.jboss.shrinkwrap.api.ShrinkWrap;
@@ -10,6 +11,7 @@
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.RegisterExtension;
 
+import io.quarkus.cache.CacheResult;
 import io.quarkus.test.QuarkusUnitTest;
 
 public class UnknownCacheTypeTest {
@@ -17,11 +19,21 @@ public class UnknownCacheTypeTest {
     @RegisterExtension
     static final QuarkusUnitTest TEST = new QuarkusUnitTest()
             .setArchiveProducer(() -> ShrinkWrap.create(JavaArchive.class)
-                    .addAsResource(new StringAsset("quarkus.cache.type=i_am_an_unknown_cache_type"), "application.properties"))
+                    .addAsResource(new StringAsset("quarkus.cache.type=i_am_an_unknown_cache_type"), "application.properties")
+                    .addClass(CachedService.class))
             .setExpectedException(DeploymentException.class);
 
     @Test
     public void shouldNotBeInvoked() {
         fail("This method should not be invoked");
     }
+
+    @ApplicationScoped
+    static class CachedService {
+
+        @CacheResult(cacheName = "test-cache")
+        public Object cachedMethod(String key) {
+            return new Object();
+        }
+    }
 }
diff --git a/extensions/cache/deployment/src/test/java/io/quarkus/cache/test/deployment/UnknownFieldCacheNameTest.java b/extensions/cache/deployment/src/test/java/io/quarkus/cache/test/deployment/UnknownFieldCacheNameTest.java
new file mode 100644
index 0000000000000..ad2df110a74be
--- /dev/null
+++ b/extensions/cache/deployment/src/test/java/io/quarkus/cache/test/deployment/UnknownFieldCacheNameTest.java
@@ -0,0 +1,48 @@
+package io.quarkus.cache.test.deployment;
+
+import static org.junit.jupiter.api.Assertions.fail;
+
+import javax.enterprise.context.ApplicationScoped;
+import javax.enterprise.context.Dependent;
+import javax.enterprise.inject.spi.DeploymentException;
+import javax.inject.Inject;
+
+import org.jboss.shrinkwrap.api.ShrinkWrap;
+import org.jboss.shrinkwrap.api.spec.JavaArchive;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+
+import io.quarkus.cache.Cache;
+import io.quarkus.cache.CacheName;
+import io.quarkus.cache.CacheResult;
+import io.quarkus.test.QuarkusUnitTest;
+
+public class UnknownFieldCacheNameTest {
+
+    @RegisterExtension
+    static final QuarkusUnitTest TEST = new QuarkusUnitTest()
+            .setArchiveProducer(() -> ShrinkWrap.create(JavaArchive.class).addClasses(CachedService.class, TestBean.class))
+            .setExpectedException(DeploymentException.class);
+
+    @Test
+    public void shouldNotBeInvoked() {
+        fail("This method should not be invoked");
+    }
+
+    @ApplicationScoped
+    static class CachedService {
+
+        @CacheResult(cacheName = "test-cache")
+        public Object getObject(Object key) {
+            return new Object();
+        }
+    }
+
+    @Dependent
+    static class TestBean {
+
+        @Inject
+        @CacheName("unknown-cache")
+        Cache cache;
+    }
+}
diff --git a/extensions/cache/deployment/src/test/java/io/quarkus/cache/test/deployment/UnknownMethodParameterCacheNameTest.java b/extensions/cache/deployment/src/test/java/io/quarkus/cache/test/deployment/UnknownMethodParameterCacheNameTest.java
new file mode 100644
index 0000000000000..c803c37ca6902
--- /dev/null
+++ b/extensions/cache/deployment/src/test/java/io/quarkus/cache/test/deployment/UnknownMethodParameterCacheNameTest.java
@@ -0,0 +1,46 @@
+package io.quarkus.cache.test.deployment;
+
+import static org.junit.jupiter.api.Assertions.fail;
+
+import javax.enterprise.context.ApplicationScoped;
+import javax.enterprise.context.Dependent;
+import javax.enterprise.inject.spi.DeploymentException;
+
+import org.jboss.shrinkwrap.api.ShrinkWrap;
+import org.jboss.shrinkwrap.api.spec.JavaArchive;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+
+import io.quarkus.cache.Cache;
+import io.quarkus.cache.CacheName;
+import io.quarkus.cache.CacheResult;
+import io.quarkus.test.QuarkusUnitTest;
+
+public class UnknownMethodParameterCacheNameTest {
+
+    @RegisterExtension
+    static final QuarkusUnitTest TEST = new QuarkusUnitTest()
+            .setArchiveProducer(() -> ShrinkWrap.create(JavaArchive.class).addClasses(CachedService.class, TestBean.class))
+            .setExpectedException(DeploymentException.class);
+
+    @Test
+    public void shouldNotBeInvoked() {
+        fail("This method should not be invoked");
+    }
+
+    @ApplicationScoped
+    static class CachedService {
+
+        @CacheResult(cacheName = "test-cache")
+        public Object getObject(Object key) {
+            return new Object();
+        }
+    }
+
+    @Dependent
+    static class TestBean {
+
+        public void unknownCacheName(@CacheName("unknown-cache") Cache cache) {
+        }
+    }
+}
diff --git a/extensions/cache/deployment/src/test/java/io/quarkus/cache/test/runtime/CacheInterceptorTest.java b/extensions/cache/deployment/src/test/java/io/quarkus/cache/test/runtime/CacheInterceptorTest.java
index 3c09b3bd669a8..feceed7dd293a 100644
--- a/extensions/cache/deployment/src/test/java/io/quarkus/cache/test/runtime/CacheInterceptorTest.java
+++ b/extensions/cache/deployment/src/test/java/io/quarkus/cache/test/runtime/CacheInterceptorTest.java
@@ -4,6 +4,7 @@
 
 import org.junit.jupiter.api.Test;
 
+import io.quarkus.cache.runtime.AbstractCache;
 import io.quarkus.cache.runtime.CacheInterceptor;
 import io.quarkus.cache.runtime.CompositeCacheKey;
 import io.quarkus.cache.runtime.DefaultCacheKey;
@@ -21,7 +22,7 @@ public void testDefaultKey() {
         cacheInfo.name = "test-cache";
         CaffeineCache cache = new CaffeineCache(cacheInfo);
 
-        DefaultCacheKey expectedKey = new DefaultCacheKey(cache.getName());
+        DefaultCacheKey expectedKey = new DefaultCacheKey(cacheInfo.name);
         Object actualKey = getCacheKey(cache, new short[] {}, new Object[] {});
         assertEquals(expectedKey, actualKey);
     }
@@ -60,7 +61,7 @@ public void testImplicitCompositeKey() {
         assertEquals(expectedKey, actualKey);
     }
 
-    private Object getCacheKey(CaffeineCache cache, short[] cacheKeyParameterPositions, Object[] methodParameterValues) {
+    private Object getCacheKey(AbstractCache cache, short[] cacheKeyParameterPositions, Object[] methodParameterValues) {
         return TEST_CACHE_INTERCEPTOR.getCacheKey(cache, cacheKeyParameterPositions, methodParameterValues);
     }
 
@@ -71,7 +72,7 @@ private Object getCacheKey(short[] cacheKeyParameterPositions, Object[] methodPa
     // This inner class changes the CacheInterceptor#getCacheKey method visibility to public.
     private static class TestCacheInterceptor extends CacheInterceptor {
         @Override
-        public Object getCacheKey(CaffeineCache cache, short[] cacheKeyParameterPositions, Object[] methodParameterValues) {
+        public Object getCacheKey(AbstractCache cache, short[] cacheKeyParameterPositions, Object[] methodParameterValues) {
             return super.getCacheKey(cache, cacheKeyParameterPositions, methodParameterValues);
         }
     }
diff --git a/extensions/cache/deployment/src/test/java/io/quarkus/cache/test/runtime/CaffeineCacheInjectionTest.java b/extensions/cache/deployment/src/test/java/io/quarkus/cache/test/runtime/CaffeineCacheInjectionTest.java
new file mode 100644
index 0000000000000..a01ffffb8ebb2
--- /dev/null
+++ b/extensions/cache/deployment/src/test/java/io/quarkus/cache/test/runtime/CaffeineCacheInjectionTest.java
@@ -0,0 +1,50 @@
+package io.quarkus.cache.test.runtime;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import javax.enterprise.context.ApplicationScoped;
+import javax.inject.Inject;
+
+import org.jboss.shrinkwrap.api.ShrinkWrap;
+import org.jboss.shrinkwrap.api.spec.JavaArchive;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+
+import io.quarkus.cache.Cache;
+import io.quarkus.cache.CacheInvalidateAll;
+import io.quarkus.cache.CacheManager;
+import io.quarkus.cache.CacheName;
+import io.quarkus.cache.runtime.caffeine.CaffeineCache;
+import io.quarkus.test.QuarkusUnitTest;
+
+public class CaffeineCacheInjectionTest {
+
+    private static final String CACHE_NAME = "test-cache";
+
+    @RegisterExtension
+    static final QuarkusUnitTest TEST = new QuarkusUnitTest()
+            .setArchiveProducer(() -> ShrinkWrap.create(JavaArchive.class).addClass(CachedService.class));
+
+    @Inject
+    CachedService cachedService;
+
+    @CacheName(CACHE_NAME)
+    Cache cache;
+
+    @Inject
+    CacheManager cacheManager;
+
+    @Test
+    public void testInjection() {
+        assertEquals(CaffeineCache.class, cache.getClass());
+        assertEquals(cache, cacheManager.getCache(CACHE_NAME).get());
+    }
+
+    @ApplicationScoped
+    static class CachedService {
+
+        @CacheInvalidateAll(cacheName = CACHE_NAME)
+        public void invalidateAll() {
+        }
+    }
+}
diff --git a/extensions/cache/deployment/src/test/java/io/quarkus/cache/test/runtime/NoOpCacheInjectionTest.java b/extensions/cache/deployment/src/test/java/io/quarkus/cache/test/runtime/NoOpCacheInjectionTest.java
new file mode 100644
index 0000000000000..3d1278adf7835
--- /dev/null
+++ b/extensions/cache/deployment/src/test/java/io/quarkus/cache/test/runtime/NoOpCacheInjectionTest.java
@@ -0,0 +1,52 @@
+package io.quarkus.cache.test.runtime;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import javax.inject.Inject;
+import javax.inject.Singleton;
+
+import org.jboss.shrinkwrap.api.ShrinkWrap;
+import org.jboss.shrinkwrap.api.asset.StringAsset;
+import org.jboss.shrinkwrap.api.spec.JavaArchive;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+
+import io.quarkus.cache.Cache;
+import io.quarkus.cache.CacheInvalidateAll;
+import io.quarkus.cache.CacheManager;
+import io.quarkus.cache.CacheName;
+import io.quarkus.cache.runtime.noop.NoOpCache;
+import io.quarkus.test.QuarkusUnitTest;
+
+public class NoOpCacheInjectionTest {
+
+    private static final String CACHE_NAME = "test-cache";
+
+    @RegisterExtension
+    static final QuarkusUnitTest TEST = new QuarkusUnitTest().setArchiveProducer(() -> ShrinkWrap.create(JavaArchive.class)
+            .addAsResource(new StringAsset("quarkus.cache.enabled=false"), "application.properties")
+            .addClass(CachedService.class));
+
+    @Inject
+    CachedService cachedService;
+
+    @CacheName(CACHE_NAME)
+    Cache cache;
+
+    @Inject
+    CacheManager cacheManager;
+
+    @Test
+    public void testInjection() {
+        assertEquals(NoOpCache.class, cache.getClass());
+        assertEquals(cache, cacheManager.getCache(CACHE_NAME).get());
+    }
+
+    @Singleton
+    static class CachedService {
+
+        @CacheInvalidateAll(cacheName = CACHE_NAME)
+        public void invalidateAll() {
+        }
+    }
+}
diff --git a/extensions/cache/deployment/src/test/java/io/quarkus/cache/test/runtime/NoOpCacheTest.java b/extensions/cache/deployment/src/test/java/io/quarkus/cache/test/runtime/NoOpCacheTest.java
new file mode 100644
index 0000000000000..482a6654ffa25
--- /dev/null
+++ b/extensions/cache/deployment/src/test/java/io/quarkus/cache/test/runtime/NoOpCacheTest.java
@@ -0,0 +1,68 @@
+package io.quarkus.cache.test.runtime;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import javax.inject.Inject;
+import javax.inject.Singleton;
+
+import org.jboss.shrinkwrap.api.ShrinkWrap;
+import org.jboss.shrinkwrap.api.asset.StringAsset;
+import org.jboss.shrinkwrap.api.spec.JavaArchive;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+
+import io.quarkus.cache.CacheInvalidate;
+import io.quarkus.cache.CacheInvalidateAll;
+import io.quarkus.cache.CacheResult;
+import io.quarkus.test.QuarkusUnitTest;
+
+public class NoOpCacheTest {
+
+    private static final String CACHE_NAME = "test-cache";
+    private static final Object KEY = new Object();
+
+    @RegisterExtension
+    static final QuarkusUnitTest TEST = new QuarkusUnitTest().setArchiveProducer(() -> ShrinkWrap.create(JavaArchive.class)
+            .addAsResource(new StringAsset("quarkus.cache.enabled=false"), "application.properties")
+            .addClass(CachedService.class));
+
+    @Inject
+    CachedService cachedService;
+
+    @Test
+    public void testAllCacheAnnotations() {
+        // STEP 1
+        // Action: @CacheResult-annotated method call.
+        // Expected effect: method invoked and result not cached.
+        // Verified by: STEP 2.
+        String value1 = cachedService.cachedMethod(KEY);
+
+        // STEP 2
+        // Action: same call as STEP 1.
+        // Expected effect: method invoked and result not cached.
+        // Verified by: different objects references between STEPS 1 and 2 results.
+        String value2 = cachedService.cachedMethod(KEY);
+        assertTrue(value1 != value2);
+
+        // The following methods have no effect at all, but let's check if they're running fine anyway.
+        cachedService.invalidate(KEY);
+        cachedService.invalidateAll();
+    }
+
+    @Singleton
+    static class CachedService {
+
+        @CacheResult(cacheName = CACHE_NAME)
+        public String cachedMethod(Object key) {
+            return new String();
+        }
+
+        @CacheInvalidate(cacheName = CACHE_NAME)
+        public void invalidate(Object key) {
+        }
+
+        @CacheInvalidateAll(cacheName = CACHE_NAME)
+        public void invalidateAll() {
+        }
+    }
+}
diff --git a/extensions/cache/deployment/src/test/java/io/quarkus/cache/test/runtime/NullKeyOrValueCacheTest.java b/extensions/cache/deployment/src/test/java/io/quarkus/cache/test/runtime/NullKeyOrValueCacheTest.java
index 6c2de8a8eed23..05047bc4e705b 100644
--- a/extensions/cache/deployment/src/test/java/io/quarkus/cache/test/runtime/NullKeyOrValueCacheTest.java
+++ b/extensions/cache/deployment/src/test/java/io/quarkus/cache/test/runtime/NullKeyOrValueCacheTest.java
@@ -1,6 +1,6 @@
 package io.quarkus.cache.test.runtime;
 
-import static io.quarkus.cache.runtime.caffeine.CaffeineCache.NULL_KEYS_NOT_SUPPORTED_MSG;
+import static io.quarkus.cache.runtime.AbstractCache.NULL_KEYS_NOT_SUPPORTED_MSG;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertThrows;
diff --git a/extensions/cache/runtime/src/main/java/io/quarkus/cache/Cache.java b/extensions/cache/runtime/src/main/java/io/quarkus/cache/Cache.java
new file mode 100644
index 0000000000000..8faeb4ee1449a
--- /dev/null
+++ b/extensions/cache/runtime/src/main/java/io/quarkus/cache/Cache.java
@@ -0,0 +1,13 @@
+package io.quarkus.cache;
+
+/**
+ * Use this interface to interact with a cache programmatically. The cache can be injected using the {@link CacheName}
+ * annotation or retrieved using {@link CacheManager}.
+ */
+public interface Cache {
+
+    /*
+     * This interface is intentionally empty for now.
+     * TODO: Add the methods that will be exposed by the programmatic API.
+     */
+}
diff --git a/extensions/cache/runtime/src/main/java/io/quarkus/cache/CacheManager.java b/extensions/cache/runtime/src/main/java/io/quarkus/cache/CacheManager.java
new file mode 100644
index 0000000000000..114d65b9345bc
--- /dev/null
+++ b/extensions/cache/runtime/src/main/java/io/quarkus/cache/CacheManager.java
@@ -0,0 +1,46 @@
+package io.quarkus.cache;
+
+import java.util.Collection;
+import java.util.Optional;
+
+/**
+ * <p>
+ * Use this interface to retrieve all existing {@link Cache} names and interact with any cache programmatically. It shares the
+ * same cache collection the Quarkus caching annotations use. The {@link CacheName} annotation can also be used to inject and
+ * access a specific cache from its name.
+ * </p>
+ * <p>
+ * Code example:
+ * 
+ * <pre>
+ * {@literal @}ApplicationScoped
+ * public class CachedService {
+ * 
+ *     {@literal @}Inject
+ *     CacheManager cacheManager;
+ *     
+ *     void doSomething() {
+ *         Cache cache = cacheManager.getCache("my-cache");
+ *         // Interact with the cache.
+ *     }
+ * }
+ * </pre>
+ * </p>
+ */
+public interface CacheManager {
+
+    /**
+     * Gets a collection of all cache names.
+     * 
+     * @return names of all caches
+     */
+    Collection<String> getCacheNames();
+
+    /**
+     * Gets the cache identified by the given name.
+     * 
+     * @param name cache name
+     * @return an {@link Optional} containing the identified cache if it exists, or an empty {@link Optional} otherwise
+     */
+    Optional<Cache> getCache(String name);
+}
diff --git a/extensions/cache/runtime/src/main/java/io/quarkus/cache/CacheName.java b/extensions/cache/runtime/src/main/java/io/quarkus/cache/CacheName.java
new file mode 100644
index 0000000000000..e5fad3e458ce9
--- /dev/null
+++ b/extensions/cache/runtime/src/main/java/io/quarkus/cache/CacheName.java
@@ -0,0 +1,45 @@
+package io.quarkus.cache;
+
+import static java.lang.annotation.ElementType.FIELD;
+import static java.lang.annotation.ElementType.METHOD;
+import static java.lang.annotation.ElementType.PARAMETER;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import javax.enterprise.util.Nonbinding;
+import javax.inject.Qualifier;
+
+/**
+ * <p>
+ * Use this annotation to inject a {@link Cache} and interact with it programmatically.
+ * </p>
+ * <p>
+ * Code example:
+ * 
+ * <pre>
+ * {@literal @}ApplicationScoped
+ * public class CachedService {
+ * 
+ *     {@literal @}CacheName("my-cache")
+ *     Cache cache;
+ *     
+ *     // Interact with the cache.
+ * }
+ * </pre>
+ * </p>
+ * 
+ * @see CacheManager
+ */
+@Qualifier
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ FIELD, METHOD, PARAMETER })
+public @interface CacheName {
+
+    /**
+     * The name of the cache.
+     */
+    @Nonbinding
+    String value();
+}
diff --git a/extensions/cache/runtime/src/main/java/io/quarkus/cache/runtime/AbstractCache.java b/extensions/cache/runtime/src/main/java/io/quarkus/cache/runtime/AbstractCache.java
new file mode 100644
index 0000000000000..12cd4e18aceb9
--- /dev/null
+++ b/extensions/cache/runtime/src/main/java/io/quarkus/cache/runtime/AbstractCache.java
@@ -0,0 +1,35 @@
+package io.quarkus.cache.runtime;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.function.Function;
+
+import io.quarkus.cache.Cache;
+
+public abstract class AbstractCache implements Cache {
+
+    public static final String NULL_KEYS_NOT_SUPPORTED_MSG = "Null keys are not supported by the Quarkus application data cache";
+
+    private Object defaultKey;
+
+    protected abstract String getName();
+
+    /**
+     * Returns the unique and immutable default key for the current cache. This key is used by the annotations caching API when
+     * a no-args method annotated with {@link io.quarkus.cache.CacheResult CacheResult} or
+     * {@link io.quarkus.cache.CacheInvalidate CacheInvalidate} is invoked.
+     * 
+     * @return default cache key
+     */
+    public Object getDefaultKey() {
+        if (defaultKey == null) {
+            defaultKey = new DefaultCacheKey(getName());
+        }
+        return defaultKey;
+    }
+
+    public abstract CompletableFuture<Object> get(Object key, Function<Object, Object> valueLoader);
+
+    public abstract void invalidate(Object key);
+
+    public abstract void invalidateAll();
+}
diff --git a/extensions/cache/runtime/src/main/java/io/quarkus/cache/runtime/CacheInterceptor.java b/extensions/cache/runtime/src/main/java/io/quarkus/cache/runtime/CacheInterceptor.java
index 202f017c1b85b..defd916f8ffb1 100644
--- a/extensions/cache/runtime/src/main/java/io/quarkus/cache/runtime/CacheInterceptor.java
+++ b/extensions/cache/runtime/src/main/java/io/quarkus/cache/runtime/CacheInterceptor.java
@@ -9,14 +9,14 @@
 import javax.interceptor.InvocationContext;
 
 import io.quarkus.arc.runtime.InterceptorBindings;
-import io.quarkus.cache.runtime.caffeine.CaffeineCache;
+import io.quarkus.cache.CacheManager;
 
 public abstract class CacheInterceptor {
 
     public static final int BASE_PRIORITY = Priority.PLATFORM_BEFORE;
 
     @Inject
-    protected CacheRepository cacheRepository;
+    CacheManager cacheManager;
 
     @SuppressWarnings("unchecked")
     protected <T> List<T> getInterceptorBindings(InvocationContext context, Class<T> bindingClass) {
@@ -33,7 +33,7 @@ protected <T> T getInterceptorBinding(InvocationContext context, Class<T> bindin
         return getInterceptorBindings(context, bindingClass).get(0);
     }
 
-    protected Object getCacheKey(CaffeineCache cache, short[] cacheKeyParameterPositions, Object[] methodParameterValues) {
+    protected Object getCacheKey(AbstractCache cache, short[] cacheKeyParameterPositions, Object[] methodParameterValues) {
         if (methodParameterValues.length == 0) {
             // If the intercepted method doesn't have any parameter, then the default cache key will be used.
             return cache.getDefaultKey();
diff --git a/extensions/cache/runtime/src/main/java/io/quarkus/cache/runtime/CacheInvalidateAllInterceptor.java b/extensions/cache/runtime/src/main/java/io/quarkus/cache/runtime/CacheInvalidateAllInterceptor.java
index 21add43b4e6f2..4ebf105a17c98 100644
--- a/extensions/cache/runtime/src/main/java/io/quarkus/cache/runtime/CacheInvalidateAllInterceptor.java
+++ b/extensions/cache/runtime/src/main/java/io/quarkus/cache/runtime/CacheInvalidateAllInterceptor.java
@@ -7,8 +7,6 @@
 
 import org.jboss.logging.Logger;
 
-import io.quarkus.cache.runtime.caffeine.CaffeineCache;
-
 @CacheInvalidateAllInterceptorBinding
 @Interceptor
 @Priority(CacheInterceptor.BASE_PRIORITY)
@@ -20,9 +18,9 @@ public class CacheInvalidateAllInterceptor extends CacheInterceptor {
     public Object intercept(InvocationContext context) throws Exception {
         for (CacheInvalidateAllInterceptorBinding binding : getInterceptorBindings(context,
                 CacheInvalidateAllInterceptorBinding.class)) {
-            CaffeineCache cache = cacheRepository.getCache(binding.cacheName());
+            AbstractCache cache = (AbstractCache) cacheManager.getCache(binding.cacheName()).get();
             if (LOGGER.isDebugEnabled()) {
-                LOGGER.debugf("Invalidating all entries from cache [%s]", cache.getName());
+                LOGGER.debugf("Invalidating all entries from cache [%s]", binding.cacheName());
             }
             cache.invalidateAll();
         }
diff --git a/extensions/cache/runtime/src/main/java/io/quarkus/cache/runtime/CacheInvalidateInterceptor.java b/extensions/cache/runtime/src/main/java/io/quarkus/cache/runtime/CacheInvalidateInterceptor.java
index 2f8265732817b..28fc1e68c8b54 100644
--- a/extensions/cache/runtime/src/main/java/io/quarkus/cache/runtime/CacheInvalidateInterceptor.java
+++ b/extensions/cache/runtime/src/main/java/io/quarkus/cache/runtime/CacheInvalidateInterceptor.java
@@ -7,8 +7,6 @@
 
 import org.jboss.logging.Logger;
 
-import io.quarkus.cache.runtime.caffeine.CaffeineCache;
-
 @CacheInvalidateInterceptorBinding
 @Interceptor
 @Priority(CacheInterceptor.BASE_PRIORITY + 1)
@@ -21,12 +19,12 @@ public Object intercept(InvocationContext context) throws Exception {
         Object key = null;
         for (CacheInvalidateInterceptorBinding binding : getInterceptorBindings(context,
                 CacheInvalidateInterceptorBinding.class)) {
-            CaffeineCache cache = cacheRepository.getCache(binding.cacheName());
+            AbstractCache cache = (AbstractCache) cacheManager.getCache(binding.cacheName()).get();
             if (key == null) {
                 key = getCacheKey(cache, binding.cacheKeyParameterPositions(), context.getParameters());
             }
             if (LOGGER.isDebugEnabled()) {
-                LOGGER.debugf("Invalidating entry with key [%s] from cache [%s]", key, cache.getName());
+                LOGGER.debugf("Invalidating entry with key [%s] from cache [%s]", key, binding.cacheName());
             }
             cache.invalidate(key);
         }
diff --git a/extensions/cache/runtime/src/main/java/io/quarkus/cache/runtime/CacheManagerImpl.java b/extensions/cache/runtime/src/main/java/io/quarkus/cache/runtime/CacheManagerImpl.java
new file mode 100644
index 0000000000000..ee2f970d09dc5
--- /dev/null
+++ b/extensions/cache/runtime/src/main/java/io/quarkus/cache/runtime/CacheManagerImpl.java
@@ -0,0 +1,40 @@
+package io.quarkus.cache.runtime;
+
+import java.util.Collections;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+
+import javax.enterprise.context.ApplicationScoped;
+
+import io.quarkus.cache.Cache;
+import io.quarkus.cache.CacheManager;
+
+@ApplicationScoped
+public class CacheManagerImpl implements CacheManager {
+
+    // There's no need for concurrency here since the caches are created at build time and never modified after that.
+    private Map<String, Cache> caches;
+    private Set<String> cacheNames;
+
+    public void setCaches(Map<String, Cache> caches) {
+        if (this.caches != null) {
+            throw new IllegalStateException("The caches map must only be set once at build time");
+        }
+        this.caches = Collections.unmodifiableMap(caches);
+        cacheNames = Collections.unmodifiableSet(caches.keySet());
+    }
+
+    @Override
+    public Set<String> getCacheNames() {
+        return cacheNames;
+    }
+
+    @Override
+    public Optional<Cache> getCache(String name) {
+        if (name == null) {
+            return Optional.empty();
+        }
+        return Optional.ofNullable(caches.get(name));
+    }
+}
diff --git a/extensions/cache/runtime/src/main/java/io/quarkus/cache/runtime/CacheProducer.java b/extensions/cache/runtime/src/main/java/io/quarkus/cache/runtime/CacheProducer.java
new file mode 100644
index 0000000000000..e5b68b5961b17
--- /dev/null
+++ b/extensions/cache/runtime/src/main/java/io/quarkus/cache/runtime/CacheProducer.java
@@ -0,0 +1,31 @@
+package io.quarkus.cache.runtime;
+
+import java.lang.annotation.Annotation;
+
+import javax.enterprise.context.ApplicationScoped;
+import javax.enterprise.inject.Produces;
+import javax.enterprise.inject.spi.InjectionPoint;
+import javax.inject.Inject;
+
+import io.quarkus.cache.Cache;
+import io.quarkus.cache.CacheManager;
+import io.quarkus.cache.CacheName;
+
+@ApplicationScoped
+public class CacheProducer {
+
+    @Inject
+    CacheManager cacheManager;
+
+    @Produces
+    @CacheName("") // The `value` attribute here is not important because it is @Nonbinding.
+    Cache produce(InjectionPoint injectionPoint) {
+        for (Annotation qualifier : injectionPoint.getQualifiers()) {
+            if (qualifier instanceof CacheName) {
+                return cacheManager.getCache(((CacheName) qualifier).value()).get();
+            }
+        }
+        // This will never be returned.
+        return null;
+    }
+}
diff --git a/extensions/cache/runtime/src/main/java/io/quarkus/cache/runtime/CacheRepository.java b/extensions/cache/runtime/src/main/java/io/quarkus/cache/runtime/CacheRepository.java
deleted file mode 100644
index 87b1d5df4d44c..0000000000000
--- a/extensions/cache/runtime/src/main/java/io/quarkus/cache/runtime/CacheRepository.java
+++ /dev/null
@@ -1,26 +0,0 @@
-package io.quarkus.cache.runtime;
-
-import java.util.Collections;
-import java.util.Map;
-
-import javax.enterprise.context.ApplicationScoped;
-
-import io.quarkus.cache.runtime.caffeine.CaffeineCache;
-
-@ApplicationScoped
-public class CacheRepository {
-
-    // There's no need for concurrency here since the map is created at build time and never modified after that.
-    private Map<String, CaffeineCache> caches;
-
-    public void setCaches(Map<String, CaffeineCache> caches) {
-        if (this.caches != null) {
-            throw new IllegalStateException("The caches map must only be set at build time");
-        }
-        this.caches = Collections.unmodifiableMap(caches);
-    }
-
-    public CaffeineCache getCache(String cacheName) {
-        return caches.get(cacheName);
-    }
-}
diff --git a/extensions/cache/runtime/src/main/java/io/quarkus/cache/runtime/CacheResultInterceptor.java b/extensions/cache/runtime/src/main/java/io/quarkus/cache/runtime/CacheResultInterceptor.java
index 0c05be23ec167..40af6bfe94586 100644
--- a/extensions/cache/runtime/src/main/java/io/quarkus/cache/runtime/CacheResultInterceptor.java
+++ b/extensions/cache/runtime/src/main/java/io/quarkus/cache/runtime/CacheResultInterceptor.java
@@ -13,8 +13,6 @@
 
 import org.jboss.logging.Logger;
 
-import io.quarkus.cache.runtime.caffeine.CaffeineCache;
-
 @CacheResultInterceptorBinding
 @Interceptor
 @Priority(CacheInterceptor.BASE_PRIORITY + 2)
@@ -26,10 +24,10 @@ public class CacheResultInterceptor extends CacheInterceptor {
     public Object intercept(InvocationContext context) throws Exception {
         CacheResultInterceptorBinding binding = getInterceptorBinding(context, CacheResultInterceptorBinding.class);
 
-        CaffeineCache cache = cacheRepository.getCache(binding.cacheName());
+        AbstractCache cache = (AbstractCache) cacheManager.getCache(binding.cacheName()).get();
         Object key = getCacheKey(cache, binding.cacheKeyParameterPositions(), context.getParameters());
         if (LOGGER.isDebugEnabled()) {
-            LOGGER.debugf("Loading entry with key [%s] from cache [%s]", key, cache.getName());
+            LOGGER.debugf("Loading entry with key [%s] from cache [%s]", key, binding.cacheName());
         }
 
         try {
diff --git a/extensions/cache/runtime/src/main/java/io/quarkus/cache/runtime/DefaultCacheKey.java b/extensions/cache/runtime/src/main/java/io/quarkus/cache/runtime/DefaultCacheKey.java
index 694cf25d087df..54181cffb8aa7 100644
--- a/extensions/cache/runtime/src/main/java/io/quarkus/cache/runtime/DefaultCacheKey.java
+++ b/extensions/cache/runtime/src/main/java/io/quarkus/cache/runtime/DefaultCacheKey.java
@@ -2,12 +2,22 @@
 
 import java.util.Objects;
 
+/**
+ * A default cache key is used by the annotations caching API when a no-args method annotated with
+ * {@link io.quarkus.cache.CacheResult CacheResult} or {@link io.quarkus.cache.CacheInvalidate CacheInvalidate} is invoked.
+ */
 public class DefaultCacheKey {
 
     private final String cacheName;
 
+    /**
+     * Constructor.
+     * 
+     * @param cacheName cache name
+     * @throws NullPointerException if the cache name is {@code null}
+     */
     public DefaultCacheKey(String cacheName) {
-        this.cacheName = cacheName;
+        this.cacheName = Objects.requireNonNull(cacheName);
     }
 
     @Override
diff --git a/extensions/cache/runtime/src/main/java/io/quarkus/cache/runtime/caffeine/CaffeineCache.java b/extensions/cache/runtime/src/main/java/io/quarkus/cache/runtime/caffeine/CaffeineCache.java
index b4030f024e9bf..bc3c61568f7c4 100644
--- a/extensions/cache/runtime/src/main/java/io/quarkus/cache/runtime/caffeine/CaffeineCache.java
+++ b/extensions/cache/runtime/src/main/java/io/quarkus/cache/runtime/caffeine/CaffeineCache.java
@@ -7,13 +7,15 @@
 import com.github.benmanes.caffeine.cache.AsyncCache;
 import com.github.benmanes.caffeine.cache.Caffeine;
 
+import io.quarkus.cache.runtime.AbstractCache;
 import io.quarkus.cache.runtime.CacheException;
-import io.quarkus.cache.runtime.DefaultCacheKey;
 import io.quarkus.cache.runtime.NullValueConverter;
 
-public class CaffeineCache {
-
-    public static final String NULL_KEYS_NOT_SUPPORTED_MSG = "Null keys are not supported by the Quarkus application data cache";
+/**
+ * This class is an internal Quarkus cache implementation. Do not use it explicitly from your Quarkus application. The public
+ * methods signatures may change without prior notice.
+ */
+public class CaffeineCache extends AbstractCache {
 
     private AsyncCache<Object, Object> cache;
 
@@ -27,8 +29,6 @@ public class CaffeineCache {
 
     private Duration expireAfterAccess;
 
-    private Object defaultKey;
-
     public CaffeineCache(CaffeineCacheInfo cacheInfo) {
         this.name = cacheInfo.name;
         Caffeine<Object, Object> builder = Caffeine.newBuilder();
@@ -51,6 +51,11 @@ public CaffeineCache(CaffeineCacheInfo cacheInfo) {
         cache = builder.buildAsync();
     }
 
+    @Override
+    protected String getName() {
+        return name;
+    }
+
     /**
      * Returns a {@link CompletableFuture} holding the cache value identified by {@code key}, obtaining that value from
      * {@code valueLoader} if necessary. The value computation is done synchronously on the calling thread and the
@@ -61,6 +66,7 @@ public CaffeineCache(CaffeineCacheInfo cacheInfo) {
      * @return a {@link CompletableFuture} holding the cache value
      * @throws CacheException if an exception is thrown during the cache value computation
      */
+    @Override
     public CompletableFuture<Object> get(Object key, Function<Object, Object> valueLoader) {
         if (key == null) {
             throw new NullPointerException(NULL_KEYS_NOT_SUPPORTED_MSG);
@@ -75,13 +81,13 @@ public CompletableFuture<Object> get(Object key, Function<Object, Object> valueL
                 cache.asMap().remove(key, newCacheValue);
                 newCacheValue.complete(new CaffeineComputationThrowable(t));
             }
-            return unwrapCacheValueOrThrowable(key, newCacheValue);
+            return unwrapCacheValueOrThrowable(newCacheValue);
         } else {
-            return unwrapCacheValueOrThrowable(key, existingCacheValue);
+            return unwrapCacheValueOrThrowable(existingCacheValue);
         }
     }
 
-    private CompletableFuture<Object> unwrapCacheValueOrThrowable(Object key, CompletableFuture<Object> cacheValue) {
+    private CompletableFuture<Object> unwrapCacheValueOrThrowable(CompletableFuture<Object> cacheValue) {
         return cacheValue.thenApply(new Function<Object, Object>() {
             @Override
             public Object apply(Object value) {
@@ -100,6 +106,7 @@ public Object apply(Object value) {
         });
     }
 
+    @Override
     public void invalidate(Object key) {
         if (key == null) {
             throw new NullPointerException(NULL_KEYS_NOT_SUPPORTED_MSG);
@@ -107,14 +114,11 @@ public void invalidate(Object key) {
         cache.synchronous().invalidate(key);
     }
 
+    @Override
     public void invalidateAll() {
         cache.synchronous().invalidateAll();
     }
 
-    public String getName() {
-        return name;
-    }
-
     // For testing purposes only.
     public Integer getInitialCapacity() {
         return initialCapacity;
@@ -134,18 +138,4 @@ public Duration getExpireAfterWrite() {
     public Duration getExpireAfterAccess() {
         return expireAfterAccess;
     }
-
-    /**
-     * Returns the unique and immutable default key for the current cache. This key is used by the annotations caching API when
-     * a no-args method annotated with {@link io.quarkus.cache.CacheResult CacheResult} or
-     * {@link io.quarkus.cache.CacheInvalidate CacheInvalidate} is invoked.
-     * 
-     * @return default cache key
-     */
-    public Object getDefaultKey() {
-        if (defaultKey == null) {
-            defaultKey = new DefaultCacheKey(getName());
-        }
-        return defaultKey;
-    }
 }
diff --git a/extensions/cache/runtime/src/main/java/io/quarkus/cache/runtime/caffeine/CaffeineCacheBuildRecorder.java b/extensions/cache/runtime/src/main/java/io/quarkus/cache/runtime/caffeine/CaffeineCacheBuildRecorder.java
index a3a86c5db4f9b..bd24bcbf7ad19 100644
--- a/extensions/cache/runtime/src/main/java/io/quarkus/cache/runtime/caffeine/CaffeineCacheBuildRecorder.java
+++ b/extensions/cache/runtime/src/main/java/io/quarkus/cache/runtime/caffeine/CaffeineCacheBuildRecorder.java
@@ -7,7 +7,8 @@
 import org.jboss.logging.Logger;
 
 import io.quarkus.arc.runtime.BeanContainer;
-import io.quarkus.cache.runtime.CacheRepository;
+import io.quarkus.cache.Cache;
+import io.quarkus.cache.runtime.CacheManagerImpl;
 import io.quarkus.runtime.annotations.Recorder;
 
 @Recorder
@@ -17,7 +18,7 @@ public class CaffeineCacheBuildRecorder {
 
     public void buildCaches(BeanContainer beanContainer, Set<CaffeineCacheInfo> cacheInfos) {
         // The number of caches is known at build time so we can use fixed initialCapacity and loadFactor for the caches map.
-        Map<String, CaffeineCache> caches = new HashMap<>(cacheInfos.size() + 1, 1.0F);
+        Map<String, Cache> caches = new HashMap<>(cacheInfos.size() + 1, 1.0F);
 
         for (CaffeineCacheInfo cacheInfo : cacheInfos) {
             if (LOGGER.isDebugEnabled()) {
@@ -30,6 +31,6 @@ public void buildCaches(BeanContainer beanContainer, Set<CaffeineCacheInfo> cach
             caches.put(cacheInfo.name, cache);
         }
 
-        beanContainer.instance(CacheRepository.class).setCaches(caches);
+        beanContainer.instance(CacheManagerImpl.class).setCaches(caches);
     }
 }
diff --git a/extensions/cache/runtime/src/main/java/io/quarkus/cache/runtime/noop/NoOpCache.java b/extensions/cache/runtime/src/main/java/io/quarkus/cache/runtime/noop/NoOpCache.java
new file mode 100644
index 0000000000000..d326ffa7d1091
--- /dev/null
+++ b/extensions/cache/runtime/src/main/java/io/quarkus/cache/runtime/noop/NoOpCache.java
@@ -0,0 +1,40 @@
+package io.quarkus.cache.runtime.noop;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.function.Function;
+
+import io.quarkus.cache.runtime.AbstractCache;
+
+/**
+ * This class is an internal Quarkus cache implementation. Do not use it explicitly from your Quarkus application. The public
+ * methods signatures may change without prior notice.
+ */
+public class NoOpCache extends AbstractCache {
+
+    private static final String NAME = NoOpCache.class.getName();
+
+    @Override
+    protected String getName() {
+        return NAME;
+    }
+
+    @Override
+    public CompletableFuture<Object> get(Object key, Function<Object, Object> valueLoader) {
+        CompletableFuture<Object> cacheValue = new CompletableFuture<Object>();
+        try {
+            Object value = valueLoader.apply(key);
+            cacheValue.complete(value);
+        } catch (Throwable t) {
+            cacheValue.completeExceptionally(t);
+        }
+        return cacheValue;
+    }
+
+    @Override
+    public void invalidate(Object key) {
+    }
+
+    @Override
+    public void invalidateAll() {
+    }
+}
diff --git a/extensions/cache/runtime/src/main/java/io/quarkus/cache/runtime/noop/NoOpCacheBuildRecorder.java b/extensions/cache/runtime/src/main/java/io/quarkus/cache/runtime/noop/NoOpCacheBuildRecorder.java
new file mode 100644
index 0000000000000..522893e96214d
--- /dev/null
+++ b/extensions/cache/runtime/src/main/java/io/quarkus/cache/runtime/noop/NoOpCacheBuildRecorder.java
@@ -0,0 +1,26 @@
+package io.quarkus.cache.runtime.noop;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
+import io.quarkus.arc.runtime.BeanContainer;
+import io.quarkus.cache.Cache;
+import io.quarkus.cache.runtime.CacheManagerImpl;
+import io.quarkus.runtime.annotations.Recorder;
+
+@Recorder
+public class NoOpCacheBuildRecorder {
+
+    public void buildCaches(BeanContainer beanContainer, Set<String> cacheNames) {
+        // The number of caches is known at build time so we can use fixed initialCapacity and loadFactor for the caches map.
+        Map<String, Cache> caches = new HashMap<>(cacheNames.size() + 1, 1.0F);
+
+        NoOpCache cache = new NoOpCache();
+        for (String cacheName : cacheNames) {
+            caches.put(cacheName, cache);
+        }
+
+        beanContainer.instance(CacheManagerImpl.class).setCaches(caches);
+    }
+}