diff --git a/ehcache-107/src/main/java/org/ehcache/jsr107/Eh107CacheManager.java b/ehcache-107/src/main/java/org/ehcache/jsr107/Eh107CacheManager.java
index 11abf7e57c..d26bdd791c 100644
--- a/ehcache-107/src/main/java/org/ehcache/jsr107/Eh107CacheManager.java
+++ b/ehcache-107/src/main/java/org/ehcache/jsr107/Eh107CacheManager.java
@@ -34,10 +34,7 @@
 import java.io.IOException;
 import java.lang.management.ManagementFactory;
 import java.net.URI;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Map;
-import java.util.Properties;
+import java.util.*;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
 
@@ -63,7 +60,7 @@ class Eh107CacheManager implements CacheManager {
   private static final MBeanServer MBEAN_SERVER = ManagementFactory.getPlatformMBeanServer();
 
   private final Object cachesLock = new Object();
-  private final ConcurrentMap<String, Eh107Cache<?, ?>> caches = new ConcurrentHashMap<>();
+  private final ConcurrentMap<String, Eh107Cache<?, ?>> lazilyLoadedCaches = new ConcurrentHashMap<>();
   private final org.ehcache.CacheManager ehCacheManager;
   private final EhcacheCachingProvider cachingProvider;
   private final ClassLoader classLoader;
@@ -82,32 +79,26 @@ class Eh107CacheManager implements CacheManager {
     this.configurationMerger = configurationMerger;
     this.statisticsService = jsr107Service.getStatistics();
 
-    refreshAllCaches();
   }
 
-  private void refreshAllCaches() {
-    for (Map.Entry<String, CacheConfiguration<?, ?>> entry : ehCacheManager.getRuntimeConfiguration().getCacheConfigurations().entrySet()) {
-      String name = entry.getKey();
-      CacheConfiguration<?, ?> config = entry.getValue();
-
-      if (!caches.containsKey(name)) {
-        Eh107Cache<?, ?> wrappedCache = wrapEhcacheCache(name, config);
-        if (caches.putIfAbsent(name, wrappedCache) == null) {
-          @SuppressWarnings("unchecked")
-          Eh107Configuration<?, ?> configuration = wrappedCache.getConfiguration(Eh107Configuration.class);
-          if (configuration.isManagementEnabled()) {
-            enableManagement(wrappedCache, true);
-          }
-          if (configuration.isStatisticsEnabled()) {
-            enableStatistics(wrappedCache, true);
-          }
+
+  private void loadCache(String cacheName) {
+    Map<String, CacheConfiguration<?, ?>> cacheConfigurations = ehCacheManager.getRuntimeConfiguration().getCacheConfigurations();
+    CacheConfiguration<?, ?> cacheConfiguration;
+
+    if (null != (cacheConfiguration = cacheConfigurations.get(cacheName))) {
+      Eh107Cache<?, ?> wrappedCache = wrapEhcacheCache(cacheName, cacheConfiguration);
+      if (lazilyLoadedCaches.putIfAbsent(cacheName, wrappedCache) == null) {
+        @SuppressWarnings("unchecked")
+        Eh107Configuration<?, ?> configuration = wrappedCache.getConfiguration(Eh107Configuration.class);
+        if (configuration.isManagementEnabled()) {
+          enableManagement(wrappedCache, true);
+        }
+        if (configuration.isStatisticsEnabled()) {
+          enableStatistics(wrappedCache, true);
         }
       }
     }
-
-    for (Eh107Cache<?, ?> wrappedCache : caches.values()) {
-      wrappedCache.isClosed();
-    }
   }
 
   private <K, V> Eh107Cache<K, V> wrapEhcacheCache(String alias, CacheConfiguration<K, V> ehConfig) {
@@ -183,7 +174,7 @@ public <K, V, C extends Configuration<K, V>> Cache<K, V> createCache(String cach
         }
         Eh107Cache<K, V> cache = wrapEhcacheCache(cacheName, (InternalCache<K, V>)ehcache);
         assert safeCacheRetrieval(cacheName) == null;
-        caches.put(cacheName, cache);
+        lazilyLoadedCaches.put(cacheName, cache);
 
         @SuppressWarnings("unchecked")
         Eh107Configuration<?, ?> configuration = cache.getConfiguration(Eh107Configuration.class);
@@ -220,7 +211,7 @@ public <K, V, C extends Configuration<K, V>> Cache<K, V> createCache(String cach
         cache = new Eh107Cache<>(cacheName, new Eh107CompleteConfiguration<>(configHolder.jsr107Configuration, ehCache
           .getRuntimeConfiguration()), cacheResources, ehCache, statisticsService, this);
 
-        caches.put(cacheName, cache);
+        lazilyLoadedCaches.put(cacheName, cache);
 
         if (configHolder.jsr107Configuration.isManagementEnabled()) {
           enableManagement(cacheName, true);
@@ -256,6 +247,7 @@ public String toString() {
   @Override
   public <K, V> Cache<K, V> getCache(String cacheName, Class<K> keyType, Class<V> valueType) {
     checkClosed();
+    loadCache(cacheName);
 
     if (cacheName == null || keyType == null || valueType == null) {
       throw new NullPointerException();
@@ -286,6 +278,7 @@ public <K, V> Cache<K, V> getCache(String cacheName, Class<K> keyType, Class<V>
   @Override
   public <K, V> Cache<K, V> getCache(String cacheName) {
     checkClosed();
+    loadCache(cacheName);
 
     if (cacheName == null) {
       throw new NullPointerException();
@@ -296,7 +289,7 @@ public <K, V> Cache<K, V> getCache(String cacheName) {
 
   @SuppressWarnings("unchecked")
   private <K, V> Eh107Cache<K, V> safeCacheRetrieval(final String cacheName) {
-    final Eh107Cache<?, ?> eh107Cache = caches.get(cacheName);
+    final Eh107Cache<?, ?> eh107Cache = lazilyLoadedCaches.get(cacheName);
     if(eh107Cache != null && eh107Cache.isClosed()) {
       return null;
     }
@@ -306,8 +299,7 @@ private <K, V> Eh107Cache<K, V> safeCacheRetrieval(final String cacheName) {
   @Override
   public Iterable<String> getCacheNames() {
     checkClosed();
-    refreshAllCaches();
-    return Collections.unmodifiableList(new ArrayList<>(caches.keySet()));
+    return Collections.unmodifiableList(new ArrayList<>(lazilyLoadedCaches.keySet()));
   }
 
   @Override
@@ -319,7 +311,7 @@ public void destroyCache(String cacheName) {
     synchronized (cachesLock) {
       checkClosed();
 
-      Eh107Cache<?, ?> cache = caches.remove(cacheName);
+      Eh107Cache<?, ?> cache = lazilyLoadedCaches.remove(cacheName);
       if (cache == null) {
         // TCK expects this method to return w/o exception if named cache does
         // not exist
@@ -447,7 +439,7 @@ public void close() {
   void closeInternal() {
     synchronized (cachesLock) {
       try {
-        closeAll(caches.values(), (Closeable) caches::clear, ehCacheManager);
+        closeAll(lazilyLoadedCaches.values(), (Closeable) lazilyLoadedCaches::clear, ehCacheManager);
       } catch (IOException e) {
         throw new CacheException(e);
       }
@@ -455,7 +447,7 @@ void closeInternal() {
   }
 
   void close(Eh107Cache<?, ?> cache) {
-    if (caches.remove(cache.getName(), cache)) {
+    if (lazilyLoadedCaches.remove(cache.getName(), cache)) {
       try {
         chain(
           () -> unregisterObject(cache.getManagementMBean()),
diff --git a/ehcache-107/src/test/java/org/ehcache/jsr107/UnwrapTest.java b/ehcache-107/src/test/java/org/ehcache/jsr107/UnwrapTest.java
index 930238a967..54dc7f9a34 100644
--- a/ehcache-107/src/test/java/org/ehcache/jsr107/UnwrapTest.java
+++ b/ehcache-107/src/test/java/org/ehcache/jsr107/UnwrapTest.java
@@ -15,6 +15,7 @@
  */
 package org.ehcache.jsr107;
 
+import org.ehcache.config.builders.CacheConfigurationBuilder;
 import org.ehcache.core.EhcacheManager;
 import org.ehcache.event.CacheEvent;
 import org.junit.After;
@@ -28,9 +29,9 @@
 import javax.cache.event.EventType;
 import javax.cache.spi.CachingProvider;
 
+import static org.ehcache.config.builders.ResourcePoolsBuilder.heap;
 import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.instanceOf;
-import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.*;
 
 /**
  * @author rism
@@ -77,6 +78,31 @@ public void testCacheEntryEventUnwrap() {
     assertThat(cacheEntryEvent.unwrap(cacheEntryEvent.getClass()), is(instanceOf(Eh107CacheEntryEvent.NormalEvent.class)));
   }
 
+  @Test
+  public void testCacheVisibilityPostUnwrap() {
+
+    CacheManager javaxCacheManager = Caching.getCachingProvider().getCacheManager();
+
+    org.ehcache.CacheManager cacheManager = javaxCacheManager.unwrap(org.ehcache.CacheManager.class);
+    CacheConfigurationBuilder<Integer, String> cacheConfigurationBuilder = CacheConfigurationBuilder.newCacheConfigurationBuilder(Integer.class, String.class, heap(5));
+    cacheManager.createCache("jcache", cacheConfigurationBuilder);
+
+    Cache<Integer, String> javaxCache = javaxCacheManager.getCache("jcache", Integer.class, String.class);
+    assertThat(javaxCache, is(notNullValue()));
+
+    CacheManager javaxCacheManager1 = javaxCacheManager.unwrap(javax.cache.CacheManager.class);
+    Cache<Integer, String> javaxCache1 = javaxCacheManager1.getCache("jcache", Integer.class, String.class);
+    assertThat(javaxCache1, is(notNullValue()));
+
+    org.ehcache.Cache<Integer, String> cache = cacheManager.getCache("jcache", Integer.class, String.class);
+    assertThat(cache, is(notNullValue()));
+
+    cache.put(1,"one");
+    assertThat(javaxCache.get(1), is("one"));
+    assertThat(javaxCache1.get(1), is("one"));
+
+  }
+
   private class EhEvent implements CacheEvent<String,String> {
     @Override
     public org.ehcache.event.EventType getType() {