@Override
  @SuppressWarnings("deprecation")
  protected Region<K, V> lookupFallback(GemFireCache gemfireCache, String regionName)
      throws Exception {
    Assert.isTrue(
        gemfireCache instanceof Cache,
        String.format("Unable to create Regions from '%1$s'.", gemfireCache));

    Cache cache = (Cache) gemfireCache;

    RegionFactory<K, V> regionFactory = createRegionFactory(cache);

    if (hubId != null) {
      enableGateway = (enableGateway == null || enableGateway);
      Assert.isTrue(enableGateway, "The 'hubId' requires the 'enableGateway' property to be true.");
      regionFactory.setGatewayHubId(hubId);
    }

    if (enableGateway != null) {
      if (enableGateway) {
        Assert.notNull(
            hubId, "The 'enableGateway' property requires the 'hubId' property to be set.");
      }
      regionFactory.setEnableGateway(enableGateway);
    }

    if (!ObjectUtils.isEmpty(gatewaySenders)) {
      Assert.isTrue(
          hubId == null,
          "It is invalid to configure a region with both a hubId and gatewaySenders."
              + " Note that the enableGateway and hubId properties are deprecated since Gemfire 7.0");

      for (Object gatewaySender : gatewaySenders) {
        regionFactory.addGatewaySenderId(((GatewaySender) gatewaySender).getId());
      }
    }

    if (!ObjectUtils.isEmpty(asyncEventQueues)) {
      for (Object asyncEventQueue : asyncEventQueues) {
        regionFactory.addAsyncEventQueueId(((AsyncEventQueue) asyncEventQueue).getId());
      }
    }

    if (!ObjectUtils.isEmpty(cacheListeners)) {
      for (CacheListener<K, V> listener : cacheListeners) {
        regionFactory.addCacheListener(listener);
      }
    }

    if (cacheLoader != null) {
      regionFactory.setCacheLoader(cacheLoader);
    }

    if (cacheWriter != null) {
      regionFactory.setCacheWriter(cacheWriter);
    }

    resolveDataPolicy(regionFactory, persistent, dataPolicy);

    if (isDiskStoreConfigurationAllowed()) {
      regionFactory.setDiskStoreName(diskStoreName);
    }

    if (scope != null) {
      regionFactory.setScope(scope);
    }

    if (attributes != null) {
      Assert.state(
          !attributes.isLockGrantor() || (scope == null) || scope.isGlobal(),
          "Lock Grantor only applies to a 'GLOBAL' scoped Region.");
    }

    postProcess(regionFactory);

    Region<K, V> region =
        (getParent() != null
            ? regionFactory.createSubregion(getParent(), regionName)
            : regionFactory.create(regionName));

    if (log.isInfoEnabled()) {
      if (getParent() != null) {
        log.info(
            String.format(
                "Created new Cache sub-Region [%1$s] under parent Region [%2$s].",
                regionName, getParent().getName()));
      } else {
        log.info(String.format("Created new Cache Region [%1$s].", regionName));
      }
    }

    if (snapshot != null) {
      region.loadSnapshot(snapshot.getInputStream());
    }

    if (attributes != null && attributes.isLockGrantor()) {
      region.becomeLockGrantor();
    }

    return region;
  }