/** * Put an object into the cache specifying both the key to use and the cache groups the object * belongs to. * * @param key Key of the object in the cache * @param groups The cache groups to add the object to * @param content The object to cache * @param policy Object that implements the refresh policy logic */ public void putInCache( String key, Object content, String[] groups, EntryRefreshPolicy policy, String origin) { CacheEntry cacheEntry = this.getCacheEntry(key, policy, origin); boolean isNewEntry = cacheEntry.isNew(); // [CACHE-118] If we have an existing entry, create a new CacheEntry so we can still access the // old one later if (!isNewEntry) { cacheEntry = new CacheEntry(key, policy); } cacheEntry.setContent(content); cacheEntry.setGroups(groups); cacheMap.put(key, cacheEntry); // Signal to any threads waiting on this update that it's now ready for them // in the cache! completeUpdate(key); if (listenerList.getListenerCount() > 0) { CacheEntryEvent event = new CacheEntryEvent(this, cacheEntry, origin); if (isNewEntry) { dispatchCacheEntryEvent(CacheEntryEventType.ENTRY_ADDED, event); } else { dispatchCacheEntryEvent(CacheEntryEventType.ENTRY_UPDATED, event); } } }
/** * Flush all entries with keys that match a given pattern * * @param pattern The key must contain this given value * @param origin The origin of this flush request * @deprecated For performance and flexibility reasons it is preferable to store cache entries in * groups and use the {@link #flushGroup(String, String)} method instead of relying on pattern * flushing. */ public void flushPattern(String pattern, String origin) { // Check the pattern if ((pattern != null) && (pattern.length() > 0)) { String key = null; CacheEntry entry = null; Iterator itr = cacheMap.keySet().iterator(); while (itr.hasNext()) { key = (String) itr.next(); if (key.indexOf(pattern) >= 0) { entry = (CacheEntry) cacheMap.get(key); if (entry != null) { flushEntry(entry, origin); } } } if (listenerList.getListenerCount() > 0) { dispatchCachePatternEvent(CacheEntryEventType.PATTERN_FLUSHED, pattern, origin); } } else { // Empty pattern, nothing to do } }
/** * Flush all entries in the cache on the given date/time. * * @param date The date at which all cache entries will be flushed. * @param origin The origin of this flush request (optional) */ public void flushAll(Date date, String origin) { flushDateTime = date; if (listenerList.getListenerCount() > 0) { dispatchCachewideEvent(CachewideEventType.CACHE_FLUSHED, date, origin); } }
/** * Completely removes a cache entry from the cache and its associated cache groups. * * @param key The key of the entry to remove. * @param origin The origin of this remove request. */ protected void removeEntry(String key, String origin) { CacheEntry cacheEntry = (CacheEntry) cacheMap.get(key); cacheMap.remove(key); if (listenerList.getListenerCount() > 0) { CacheEntryEvent event = new CacheEntryEvent(this, cacheEntry, origin); dispatchCacheEntryEvent(CacheEntryEventType.ENTRY_REMOVED, event); } }
/** * Flush a cache entry. On completion of the flush, a <tt>CacheEntryEventType.ENTRY_FLUSHED</tt> * event is fired. * * @param entry The entry to flush * @param origin The origin of this flush event (optional) */ private void flushEntry(CacheEntry entry, String origin) { String key = entry.getKey(); // Flush the object itself entry.flush(); if (!entry.isNew()) { // Update the entry's state in the map cacheMap.put(key, entry); } // Trigger an ENTRY_FLUSHED event. [CACHE-107] Do this for all flushes. if (listenerList.getListenerCount() > 0) { CacheEntryEvent event = new CacheEntryEvent(this, entry, origin); dispatchCacheEntryEvent(CacheEntryEventType.ENTRY_FLUSHED, event); } }
/** * Flushes all unexpired objects that belong to the supplied group. On completion this method * fires a <tt>CacheEntryEventType.GROUP_FLUSHED</tt> event. * * @param group The group to flush * @param origin The origin of this flush event (optional) */ public void flushGroup(String group, String origin) { // Flush all objects in the group Set groupEntries = cacheMap.getGroup(group); if (groupEntries != null) { Iterator itr = groupEntries.iterator(); String key; CacheEntry entry; while (itr.hasNext()) { key = (String) itr.next(); entry = (CacheEntry) cacheMap.get(key); if ((entry != null) && !entry.needsRefresh(CacheEntry.INDEFINITE_EXPIRY)) { flushEntry(entry, NESTED_EVENT); } } } if (listenerList.getListenerCount() > 0) { dispatchCacheGroupEvent(CacheEntryEventType.GROUP_FLUSHED, group, origin); } }
public void dispose() { destroySession(); while (listeners.getListenerCount() > 0) removeSessionListener(listeners.getListeners(SessionListener.class)[0]); listeners = null; }