org.dd4t.caching.CacheElement java code examples

Add the Codota plugin to your IDE and get smart completions

private void myMethod () {
 SimpleDateFormat s =String pattern;new SimpleDateFormat(pattern)
String template;Locale locale;new SimpleDateFormat(template, locale)
new SimpleDateFormat()
Smart code suggestions by Tabnine
}

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();

/**
 * 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);
}

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;
}

@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);
  }
}

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;
}

String dependencyKey = cacheElement.getDependentKey();
if (dependencyKey != null) {

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

Element dependencyElement = dependencyCache.get(dependencyKey);
if (dependencyElement != null) {
  cacheSet = ((CacheElement<ConcurrentSkipListSet<String>>) dependencyElement.getObjectValue()).getPayload();
  setNotExpired(dependencyElement);
  if (oldElement != null) {
    ConcurrentSkipListSet<String> oldCacheSet = ((CacheElement<ConcurrentSkipListSet<String>>) oldElement
        .getObjectValue()).getPayload();
    if (oldCacheSet != null) {
      cacheSet.addAll(oldCacheSet);

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();

@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);
  }
}

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);
  }
}

ConcurrentSkipListSet<String> cacheSet = dependentEntry.getPayload();
if (cacheSet != null) {
  for (String cacheKey : cacheSet) {

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 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;
}

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();

String pageSource;
if (cacheElement.isExpired()) {
    if (cacheElement.isExpired()) {
        cacheElement.setPayload(null);
        cacheProvider.storeInItemCache(cacheKey, cacheElement);
        cacheElement.setExpired(true);
        throw new ItemNotFoundException("Unable to find page by id " + tcmId);
      cacheElement.setPayload(pageSource);
      cacheProvider.storeInItemCache(cacheKey, cacheElement);
      cacheElement.setExpired(false);
    } else {
      LOG.debug("Return a page with uri: {} from cache", tcmId);
      pageSource = cacheElement.getPayload();
  pageSource = cacheElement.getPayload();

Javadoc

Wrapper around a 'payload' object that represents the actual object in the cache. The payload is wrapped inside this cache element object, so we can differentiate between null and not-null payloads. The cache element can also contain empty (null) payloads.

Most used methods

Popular in Java

Reading from database using SQL prepared statement
notifyDataSetChanged (ArrayAdapter)
scheduleAtFixedRate (Timer)
startActivity (Activity)
String (java.lang)
Socket (java.net)
Provides a client-side TCP socket.
HashMap (java.util)
HashMap is an implementation of Map. All optional operations are supported.All elements are permitte
LinkedHashMap (java.util)
LinkedHashMap is an implementation of Map that guarantees iteration order. All optional operations a
Map (java.util)
A Map is a data structure consisting of a set of keys and values in which each key is mapped to a si
Response (javax.ws.rs.core)
Defines the contract between a returned instance and the runtime when an application needs to provid
21 Best IntelliJ Plugins

How to useCacheElement in org.dd4t.caching

Best Java code snippets using org.dd4t.caching.CacheElement (Showing top 20 results out of 315)

How to use
CacheElement
in
org.dd4t.caching