Author: nzamosenchuk Date: 2011-12-05 05:00:55 -0500 (Mon, 05 Dec 2011) New Revision: 5261 Modified: core/trunk/exo.core.component.organization.api/src/main/java/org/exoplatform/services/organization/CacheHandler.java Log: EXOJCR-1663 : allow descendant CacheHandler classes to expose prefixes into cacheKeys Modified: core/trunk/exo.core.component.organization.api/src/main/java/org/exoplatform/services/organization/CacheHandler.java =================================================================== --- core/trunk/exo.core.component.organization.api/src/main/java/org/exoplatform/services/organization/CacheHandler.java 2011-12-05 09:58:13 UTC (rev 5260) +++ core/trunk/exo.core.component.organization.api/src/main/java/org/exoplatform/services/organization/CacheHandler.java 2011-12-05 10:00:55 UTC (rev 5261) @@ -19,13 +19,37 @@ package org.exoplatform.services.organization; import org.exoplatform.services.cache.CacheService; +import org.exoplatform.services.cache.CachedObjectSelector; import org.exoplatform.services.cache.ExoCache; +import org.exoplatform.services.cache.ObjectCacheInfo; import java.io.Serializable; import java.util.HashMap; import java.util.Map; /** + * Cache handler is an entity used to organize access to underlying {@link ExoCache} from Organization Service. + * It manages caches for each type of Organization Service entries internally. + * <p> + * Some organization services relies on multiple data-sources, like JCROrgService. + * The last one can use multiple repositories. For this case, CacheHandler provides a way for customizing access + * to underlying caches for managing multiple sources of data. Caches for data-sources are isolated using key's + * prefixes. Providing an isolation, CacheHandler doesn't create additional cache instances offering better + * memory usage. + * <p> + * Descendant CacheHandler classes that requires caches for multiple data-sources must override following + * protected internal menthods: + * <ul> + * <li>{@link CacheHandler#createCacheKey(Serializable)}<p>- Taking OrgService key as an argument, it generates + * a key, that contains data-source identifier. This key is used as cache key. I.e. it takes "user1" and + * produces "repository2:user1";</li> + * <li>{@link CacheHandler#createOrgServiceKey(Serializable)}<p> + * - This is an opposite operation to createCacheKey(Serializable), it produces OrgService key trimming + * data-source metadata. I.e. taking "repostiory2:user1" it returns "user1";</li> + * <li>{@link CacheHandler#matchKey(Serializable)}<p> - checks if key provided as argument corresponds to + * current cacheHandler instance. I.e. checks if key starts with current prefix.</li> + * </ul> + * * @author <a href=&quot;abazko(a)exoplatform.com&quot;&gt;Anatoliy Bazko</a> * @version $Id: CacheHandler.java 34360 2009-07-22 23:58:59Z tolusha $ */ @@ -79,7 +103,7 @@ public void put(Serializable key, Object value, CacheType cacheType) { - key = createInternalKey(key); + key = createCacheKey(key); if (cacheType == CacheType.USER) { @@ -106,7 +130,7 @@ public Object get(Serializable key, CacheType cacheType) { Object obj = null; - key = createInternalKey(key); + key = createCacheKey(key); if (cacheType == CacheType.USER) { @@ -142,14 +166,24 @@ { try { - for (Membership m : membershipCache.getCachedObjects()) + membershipCache.select(new CachedObjectSelector<Serializable, Membership>() { - String mkey = getMembershipKey(m); - if (mkey.indexOf((String)key) >= 0) + public boolean select(Serializable cacheKey, ObjectCacheInfo<? extends Membership> ocinfo) { - membershipCache.remove(createInternalKey(mkey)); + return matchKey(cacheKey); } - } + + public void onSelect(ExoCache<? extends Serializable, ? extends Membership> cache, + Serializable cacheKey, ObjectCacheInfo<? extends Membership> ocinfo) throws Exception + { + String mkey = getMembershipKey(ocinfo.get()); + String key = (String)createOrgServiceKey(cacheKey); + if ((mkey.indexOf(key) >= 0)) + { + cache.remove(cacheKey); + } + } + }); } catch (Exception e) { @@ -157,7 +191,7 @@ } else { - key = createInternalKey(key); + key = createCacheKey(key); if (cacheType == CacheType.USER) { @@ -182,19 +216,31 @@ { if (cacheType == CacheType.MEMBERSHIP) { + try { - Map<Serializable, Membership> wait4Adding = new HashMap<Serializable, Membership>(); - - for (Membership m : membershipCache.getCachedObjects()) + final Map<Serializable, Membership> wait4Adding = new HashMap<Serializable, Membership>(); + final Serializable finalNewKey = newKey; + membershipCache.select(new CachedObjectSelector<Serializable, Membership>() { - String mkey = getMembershipKey(m); - if (mkey.indexOf((String)oldKey) >= 0) + public boolean select(Serializable cacheKey, ObjectCacheInfo<? extends Membership> ocinfo) { - wait4Adding.put(createInternalKey(mkey.replace((String)oldKey, (String)newKey)), - membershipCache.remove(createInternalKey(mkey))); + return matchKey(cacheKey); } - } + + public void onSelect(ExoCache<? extends Serializable, ? extends Membership> cache, + Serializable cacheKey, ObjectCacheInfo<? extends Membership> ocinfo) throws Exception + { + String mkey = getMembershipKey(ocinfo.get()); + String key = (String)createOrgServiceKey(cacheKey); + if ((mkey.indexOf(key) >= 0)) + { + wait4Adding.put(createCacheKey(mkey.replace(key, (String)finalNewKey)), + cache.remove(createCacheKey(mkey))); + } + } + + }); membershipCache.putMap(wait4Adding); } catch (Exception e) @@ -203,8 +249,8 @@ } else { - oldKey = createInternalKey(oldKey); - newKey = createInternalKey(newKey); + oldKey = createCacheKey(oldKey); + newKey = createCacheKey(newKey); if (cacheType == CacheType.USER) { @@ -252,9 +298,35 @@ /** * Provide a way of defining cache prefixes for descendant classes. * This factory method is executed for each cache operation (put, get, remove) + * + * @param orgServiceKey - key used by Organization Service; + * @return key, used to define cache item. */ - protected Serializable createInternalKey(Serializable key) + protected Serializable createCacheKey(Serializable orgServiceKey) { - return key; + return orgServiceKey; } + + /** + * Asserts whether key is managed by current CacheHandler + * + * @param cacheKey + * @return + */ + protected boolean matchKey(Serializable cacheKey) + { + return true; + } + + /** + * Opposite to createCacheKey(Serializable), retrieving Organization Service key from + * Cache key, trimming all data-source metadata. + * + * @param cacheKey + * @return + */ + protected Serializable createOrgServiceKey(Serializable cacheKey) + { + return cacheKey; + } }