How to use org.dd4t.caching

private static boolean validInCache(final CacheElement<String> cacheElement) {
  if (cacheElement.isExpired()) {
    //noinspection SynchronizationOnLocalVariableOrMethodParameter
    synchronized (cacheElement) {
      if (cacheElement.isExpired()) {
        cacheElement.setExpired(false);
        return false;
      }
    }
  }
  return true;
}

private void setNotExpired(Element dependentElement) {
  if (dependentElement == null) {
    return;
  }
  CacheElement cacheElement = (CacheElement) dependentElement.getObjectValue();
  if (cacheElement.isExpired()) {
    cacheElement.setExpired(false);
    updateTTL(dependentElement);
  }
}

public void setExpired(Element element, int adjustTTL) {
  if (!isEnabled()) {
    return;
  }
  if (element == null) {
    return;
  }
  if (element.getObjectValue() instanceof CacheElement) {
    CacheElement cacheElement = (CacheElement) element.getObjectValue();
    if (!cacheElement.isExpired()) {
      cacheElement.setExpired(true);
      expireElement(element, adjustTTL);
    }
  } else {
    expireElement(element, adjustTTL);
  }
}

if (cacheElement.isExpired()) {
    if (cacheElement.isExpired()) {
        cacheElement.setPayload(publicationMeta);
        cacheProvider.storeInItemCache(key, cacheElement);
        cacheElement.setExpired(false);
        LOG.debug("Stored Publication Meta with key: {} in cache", key);
      } else {
      publicationMeta = cacheElement.getPayload();
  publicationMeta = cacheElement.getPayload();

@Override
public <T> void storeInItemCache(String key, CacheElement<T> cacheElement, List<CacheDependency> dependencies) {
  if (!isEnabled()) {
    return;
  }
  if (!cacheExists()) {
    LOG.error("Cache configuration is invalid! NOT Caching. Check EH Cache configuration.");
    return;
  }
  // detect undeclared nulls, complain, and set to null
  if (!cacheElement.isNull() && cacheElement.getPayload() == null) {
    Exception exToLogToHaveStacktraceWhoCausedIt = new Exception();
    LOG.error("Detected undeclared null payload on element with key " + key + " at insert time!",
        exToLogToHaveStacktraceWhoCausedIt);
    cacheElement.setNull(true);
  }
  cacheElement.setExpired(false);
  Element element = cache.get(key);
  if (element == null) {
    element = new Element(key, cacheElement);
  }
  cache.put(element);
  element.setTimeToLive(cacheDependencyTTL);
  for (CacheDependency dep : dependencies) {
    String dependentKey = getKey(dep.getPublicationId(), dep.getItemId());
    cacheElement.setDependentKey(dependentKey);
    addDependency(key, dependentKey);
    updateTTL(dependencyCache.get(dependentKey));
  }
}

@Override
public <T> void storeInItemCache(final String key, final CacheElement<T> cacheElement, final
List<CacheDependency> dependencies) {
  if (!isEnabled()) {
    return;
  }
  if (!cacheExists()) {
    LOG.error("Cache configuration is invalid! NOT Caching. Check EH Cache configuration.");
    return;
  }
  // detect undeclared nulls, complain, and set to null
  if (!cacheElement.isNull() && cacheElement.getPayload() == null) {
    Exception exToLogToHaveStacktraceWhoCausedIt = new Exception();
    LOG.error("Detected undeclared null payload on element with key " + key + " at insert time!",
        exToLogToHaveStacktraceWhoCausedIt);
    cacheElement.setNull(true);
    cacheElement.setExpired(true);
  }
  cacheElement.setExpired(false);
  if (cache.containsKey(key)) {
    cache.replace(key, cacheElement);
  } else {
    cache.put(key, cacheElement);
  }
  for (CacheDependency dep : dependencies) {
    String dependentKey = getKey(dep.getPublicationId(), dep.getItemId());
    cacheElement.setDependentKey(dependentKey);
    addDependency(key, dependentKey);
  }
}

/**
 * Store given item in the cache with a simple time-to-live property.
 *
 * @param key          String representing the key to store the payload under
 * @param cacheElement CacheElement a wrapper around the actual value to store in
 *                     cache
 */
@Override
public <T> void storeInItemCache(String key, CacheElement<T> cacheElement) {
  if (!isEnabled()) {
    return;
  }
  if (!cacheExists()) {
    LOG.error("Cache configuration is invalid! NOT Caching. Check EH Cache configuration.");
    return;
  }
  // detect undeclared nulls, complain, and set to null
  if (!cacheElement.isNull() && cacheElement.getPayload() == null) {
    Exception exToLogToHaveStacktraceWhoCausedIt = new Exception();
    LOG.error("Detected undeclared null payload on element with key " + key + " at insert time!",
        exToLogToHaveStacktraceWhoCausedIt);
    cacheElement.setNull(true);
  }
  cacheElement.setExpired(false);
  storeElement(key, cacheElement);
}

@Override
public void addDependency(final String cacheKey, final String dependencyKey) {
  if (!isEnabled()) {
    return;
  }
  if (!dependencyCacheExists()) {
    LOG.error("Cache configuration is invalid! NOT Caching. Check EH Cache configuration.");
    return;
  }
  LOG.debug("Add dependency from key: {} to key: {}", dependencyKey, cacheKey);
  if (dependencyCache.containsKey(dependencyKey)) {
    CacheElement<ConcurrentSkipListSet<String>> dependencyElement = dependencyCache.get(dependencyKey);
    if (dependencyElement != null && dependencyElement.getPayload() != null) {
      ConcurrentSkipListSet<String> cacheSet = dependencyElement.getPayload();
      if (!cacheSet.contains(cacheKey)) {
        LOG.info("Adding cachekey: {} to dependent key: {}", cacheKey, dependencyKey);
        cacheSet.add(cacheKey);
      }
      dependencyElement.setExpired(false);
      dependencyCache.replace(dependencyKey, dependencyElement);
    } else {
      addNewDependencyCacheElement(cacheKey, dependencyKey);
    }
  } else {
    addNewDependencyCacheElement(cacheKey, dependencyKey);
  }
  LOG.info("Added or replaced cache element with dependency key: {} and dependent key: {}", dependencyKey,
      cacheKey);
}

@Override
public void invalidate(final String key) {
  if (!isEnabled()) {
    return;
  }
  if (dependencyCache == null) {
    LOG.error("Cache configuration is invalid! NOT Caching. Check EH Cache configuration.");
    return;
  }
  String dependencyKey = getKey(key);
  Element dependencyElement = dependencyCache.get(dependencyKey);
  if (dependencyElement != null) {
    LOG.info("Expire key: {} from dependency cache", dependencyKey);
    setExpired(dependencyElement, ADJUST_TTL);
    ConcurrentSkipListSet<String> cacheSet = ((CacheElement<ConcurrentSkipListSet<String>>) dependencyElement
        .getObjectValue()).getPayload();
    if (cacheSet != null) {
      for (String cacheKey : cacheSet) {
        LOG.debug("Expire cache key: {} from cache", cacheKey);
        Element cacheElement = cache.get(cacheKey);
        setExpired(cacheElement, 0);
      }
    }
  } else {
    LOG.info("Attempting to expire key {} but not found in dependency cache", dependencyKey);
  }
}

@Override
public void invalidate(final String key) {
  if (!isEnabled()) {
    return;
  if (!dependencyCacheExists()) {
    LOG.error("Cache configuration is invalid! NOT Caching. Check EH Cache configuration.");
    return;
  String dependencyKey = getKey(key);
  if (!dependencyCache.containsKey(dependencyKey)) {
    LOG.debug("No dependency key found for key:{}. Doing nothing");
    ConcurrentSkipListSet<String> cacheSet = dependentEntry.getPayload();
    if (cacheSet != null) {
      for (String cacheKey : cacheSet) {

@Override
public void onMessage(Message message) {
  CacheEvent event = getCacheEvent(message);
  if (event != null) {
    switch (event.getType()) {
      case CacheEvent.INVALIDATE:
        LOG.debug("Invalidate " + event);
        Serializable key = event.getKey();
        cacheInvalidator.invalidate(stripNamespaceIfRequired(key.toString()));
        monitor.setMQServerStatusUp();
        break;
      case CacheEvent.FLUSH:
        LOG.debug("Flush " + event);
        monitor.setMQServerStatusUp();
        break;
      default:
        break;
    }
  }
}

@Override
public String resolve(String componentURI, String pageURI) throws ItemNotFoundException, SerializationException {
  String key;
  if (!StringUtils.isEmpty(pageURI)) {
    key = getCacheKey(componentURI, pageURI);
  } else {
    key = getCacheKey(componentURI);
  }
  final CacheElement<String> cacheElement = cacheProvider.loadPayloadFromLocalCache(key);
  String result;
  if (!validInCache(cacheElement)) {
    if (!StringUtils.isEmpty(pageURI)) {
      result = linkProvider.resolveComponentFromPage(componentURI, pageURI);
    } else {
      result = linkProvider.resolveComponent(componentURI);
    }
    try {
      result = addToCache(componentURI, key, cacheElement, result);
    } catch (ParseException e) {
      String message = String.format("Invalid ComponentURI %s", componentURI);
      LOG.error(message);
      throw new SerializationException(message, e);
    }
  } else {
    result = cacheElement.getPayload();
    LOG.debug("Return link url: {} for uri: {} from cache", result, componentURI);
  }
  return result;
}

private String addToCache(String componentURI, String key, CacheElement<String> cacheElement, String result)
    throws ParseException {
  String toReturn = result == null ? "" : result;
  cacheElement.setPayload(toReturn);
  TCMURI tcmUri = new TCMURI(componentURI);
  cacheProvider.storeInItemCache(key, cacheElement, tcmUri.getPublicationId(), tcmUri.getItemId());
  LOG.debug("Added link url: {} for uri: {} to cache", result, componentURI);
  return toReturn;
}

  @Override
  public void run() {
    LOG.debug("Monitor thread running");
    MQServerStatus previousServerStatus = MQServerStatus.UP;
    try {
      while (!Thread.currentThread().isInterrupted()) {
        LOG.debug("JMS MQ server is {} ", serverStatus);
        if (cacheInvalidator != null) {
          if (isMQServerDown()) {
            cacheInvalidator.flush();
          } else if (previousServerStatus == MQServerStatus.DOWN) {
            LOG.debug("JMS MQ server recovered. Flush local cache one more time.");
            cacheInvalidator.flush();
          }
          previousServerStatus = serverStatus;
        }
        Thread.sleep(monitorServiceInterval);
      }
    } catch (InterruptedException e) {
      LOG.debug("Cache monitor thread interrupted");
      Thread.currentThread().interrupt();
    }
  }
};

Integer result = Constants.UNKNOWN_PUBLICATION_ID;
if (cacheElement.isExpired()) {
    if (cacheElement.isExpired()) {
      cacheElement.setPayload(result);
      cacheProvider.storeInItemCache(key, cacheElement);
      cacheElement.setExpired(false);
      LOG.debug("Stored Publication Id with key: {} in cache", key);
    } else {
      LOG.debug("Fetched a Publication Id with key: {} from cache", key);
      result = cacheElement.getPayload();
  result = cacheElement.getPayload();

if (cacheElement.isExpired()) {
    if (cacheElement.isExpired()) {
        cacheElement.setPayload(publicationMeta);
        cacheProvider.storeInItemCache(key, cacheElement);
        cacheElement.setExpired(false);
        LOG.debug("Stored Publication Meta with key: {} in cache", key);
      } else {
      publicationMeta = cacheElement.getPayload();
  publicationMeta = cacheElement.getPayload();

Integer result = Constants.UNKNOWN_PUBLICATION_ID;
if (cacheElement.isExpired()) {
    if (cacheElement.isExpired()) {
      cacheElement.setPayload(result);
      cacheProvider.storeInItemCache(key, cacheElement);
      cacheElement.setExpired(false);
      LOG.debug("Stored Publication Id with key: {} in cache", key);
    } else {
      LOG.debug("Fetched a Publication Id with key: {} from cache", key);
      result = cacheElement.getPayload();
  result = cacheElement.getPayload();

Integer result = Constants.UNKNOWN_PUBLICATION_ID;
if (cacheElement.isExpired()) {
    if (cacheElement.isExpired()) {
        result = pageMeta.getPublicationId();
        LOG.debug("Publication Id for URL: {}, is {}", url, result);
        cacheElement.setPayload(result);
        cacheProvider.storeInItemCache(key, cacheElement);
        cacheElement.setExpired(false);
        LOG.debug("Stored Publication Id with key: {} in cache", key);
      } else {
      result = cacheElement.getPayload();
  result = cacheElement.getPayload();

Integer result = Constants.UNKNOWN_PUBLICATION_ID;
if (cacheElement.isExpired()) {
    if (cacheElement.isExpired()) {
        cacheElement.setPayload(result);
        cacheProvider.storeInItemCache(key, cacheElement);
        cacheElement.setExpired(false);
        LOG.debug("Publication Id for URL: {}, is {}", url, result);
      } else {
    } else {
      LOG.debug("Fetched a Publication Id with key: {} from cache", key);
      result = cacheElement.getPayload();
  result = cacheElement.getPayload();

Binary binary;
if (cacheElement.isExpired()) {
    if (cacheElement.isExpired()) {
      try {
        binary = binaryProvider.getBinaryByURI(tcmUri);
        cacheElement.setPayload(binary);
        TCMURI binaryURI = new TCMURI(tcmUri);
        cacheProvider.storeInItemCache(tcmUri, cacheElement, binaryURI.getPublicationId(), binaryURI
            .getItemId());
        cacheElement.setExpired(false);
        LOG.debug("Added binary with uri: {} to cache", tcmUri);
      } catch (ParseException e) {
        cacheElement.setPayload(null);
        cacheProvider.storeInItemCache(tcmUri, cacheElement);
        cacheElement.setExpired(true);
        throw new ItemNotFoundException(e);
      binary = cacheElement.getPayload();
  binary = cacheElement.getPayload();