diff --git a/107/src/main/java/org/ehcache/jsr107/Eh107CacheManager.java b/107/src/main/java/org/ehcache/jsr107/Eh107CacheManager.java
index 92a15e4397..49fba53e4e 100644
--- a/107/src/main/java/org/ehcache/jsr107/Eh107CacheManager.java
+++ b/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,25 +79,22 @@ 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();
-      caches.putIfAbsent(name, wrapEhcacheCache(name, config));
-    }
-    for (Map.Entry<String, Eh107Cache<?, ?>> namedCacheEntry : caches.entrySet()) {
-      Eh107Cache<?, ?> cache = namedCacheEntry.getValue();
-      if (!cache.isClosed()) {
+  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 = cache.getConfiguration(Eh107Configuration.class);
+        Eh107Configuration<?, ?> configuration = wrappedCache.getConfiguration(Eh107Configuration.class);
         if (configuration.isManagementEnabled()) {
-          enableManagement(cache, true);
+          enableManagement(wrappedCache, true);
         }
         if (configuration.isStatisticsEnabled()) {
-          enableStatistics(cache, true);
+          enableStatistics(wrappedCache, true);
         }
       }
     }
@@ -179,7 +173,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);
@@ -216,7 +210,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);
@@ -252,6 +246,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();
@@ -282,6 +277,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();
@@ -292,7 +288,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;
     }
@@ -302,8 +298,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
@@ -315,7 +310,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
@@ -443,7 +438,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);
       }
@@ -451,7 +446,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/107/src/test/java/org/ehcache/jsr107/UnwrapTest.java b/107/src/test/java/org/ehcache/jsr107/UnwrapTest.java
index a3233c0fe4..54dc7f9a34 100644
--- a/107/src/test/java/org/ehcache/jsr107/UnwrapTest.java
+++ b/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.core.Is.is;
-import static org.hamcrest.core.IsInstanceOf.instanceOf;
+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() {