congrats Icon
New! Announcing Tabnine Chat Beta
Learn More
Tabnine Logo
org.dd4t.caching
Code IndexAdd Tabnine to your IDE (free)

How to use org.dd4t.caching

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

origin: org.dd4t/dd4t-core

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;
}
origin: org.dd4t/dd4t-caching

private void setNotExpired(Element dependentElement) {
  if (dependentElement == null) {
    return;
  }
  CacheElement cacheElement = (CacheElement) dependentElement.getObjectValue();
  if (cacheElement.isExpired()) {
    cacheElement.setExpired(false);
    updateTTL(dependentElement);
  }
}
origin: org.dd4t/dd4t-caching

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);
  }
}
origin: org.dd4t/dd4t-providers

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();
origin: org.dd4t/dd4t-caching

@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));
  }
}
origin: org.dd4t/dd4t-caching

@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);
  }
}
origin: org.dd4t/dd4t-caching

/**
 * 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);
}
origin: org.dd4t/dd4t-caching

@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);
}
origin: org.dd4t/dd4t-caching

@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);
  }
}
origin: org.dd4t/dd4t-caching

@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) {
origin: org.dd4t/dd4t-caching

@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;
    }
  }
}
origin: org.dd4t/dd4t-core

@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;
}
origin: org.dd4t/dd4t-core

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;
}
origin: org.dd4t/dd4t-caching

  @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();
    }
  }
};
origin: org.dd4t/dd4t-providers-web8

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();
origin: org.dd4t/dd4t-providers-web8

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();
origin: org.dd4t/dd4t-providers

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();
origin: org.dd4t/dd4t-providers-web8

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();
origin: org.dd4t/dd4t-providers

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();
origin: org.dd4t/dd4t-core

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();
org.dd4t.caching

Most used classes

  • CacheElement
    Wrapper around a 'payload' object that represents the actual object in the cache. The payload is wra
  • CacheDependency
    Interface determines the necessary data to act as a cache dependency
  • CacheInvalidator
  • CacheDependencyImpl
    Basic implementation class for a CacheDependency. Supports creation through constructor as well as s
  • CacheElementImpl
    Wrapper around a 'payload' object that represents the actual object in the cache. The payload is wra
  • JMSCacheMonitor,
  • AbstractEHCacheProvider,
  • EHCache3Provider,
  • EHCacheProvider
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now