/**
* Licensed to Jasig under one or more contributor license
* agreements. See the NOTICE file distributed with this work
* for additional information regarding copyright ownership.
* Jasig licenses this file to you under the Apache License,
* Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a
* copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on
* an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.jasig.portal.utils.cache;
import java.util.Map;
import java.util.Properties;
import net.sf.ehcache.CacheException;
import net.sf.ehcache.Ehcache;
import net.sf.ehcache.Element;
import net.sf.ehcache.event.CacheEventListener;
import net.sf.ehcache.event.CacheEventListenerAdapter;
import net.sf.ehcache.event.CacheEventListenerFactory;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.google.common.collect.ImmutableMap;
/**
* Returns references to Spring configured {@link CacheEventListener}s
*/
@Service
public class SpringCacheEventListenerFactory extends CacheEventListenerFactory implements DisposableBean {
public static final String BEAN_NAME = "beanName";
private static final Logger LOGGER = LoggerFactory.getLogger(SpringCacheEventListenerFactory.class);
private static final CacheEventListener NOOP_CACHE_EVENT_LISTENER = new CacheEventListenerAdapter();
private static volatile Map<String, CacheEventListener> cacheEventListeners;
@Autowired
public void setCacheEventListeners(Map<String, CacheEventListener> cacheEventListeners) {
SpringCacheEventListenerFactory.cacheEventListeners = ImmutableMap.copyOf(cacheEventListeners);
}
@Override
public void destroy() throws Exception {
cacheEventListeners = null;
}
@Override
public CacheEventListener createCacheEventListener(Properties properties) {
final String beanName = StringUtils.trimToNull(properties.getProperty(BEAN_NAME));
if (beanName == null) {
throw new IllegalArgumentException("The " + BEAN_NAME + " property must be set");
}
return new LazyCacheEventListener(beanName);
}
private static class LazyCacheEventListener implements CacheEventListener {
private final String beanName;
private CacheEventListener delegate;
public LazyCacheEventListener(String beanName) {
this.beanName = beanName;
}
/**
* Always resolves to the same delegate object, no need for thread-sync checks
*/
private CacheEventListener getDelegate() {
CacheEventListener d = this.delegate;
if (d == null) {
//Need a local reference here to avoid locking around cacheEventListeners reference changes
final Map<String, CacheEventListener> cel = cacheEventListeners;
if (cel == null) {
//either pre-init or post-destroy, return noop logger
return NOOP_CACHE_EVENT_LISTENER;
}
final CacheEventListener cacheEventListener = cel.get(beanName);
if (cacheEventListener == null) {
//If no listener is found just use the noop listener
LOGGER.warn("No CacheEventListener bean found for name '" + beanName + "', using NOOP CacheEventListener instead.");
d = NOOP_CACHE_EVENT_LISTENER;
}
else {
d = cacheEventListener;
}
this.delegate = d;
}
return d;
}
@Override
public void notifyElementRemoved(Ehcache cache, Element element) throws CacheException {
this.getDelegate().notifyElementRemoved(cache, element);
}
@Override
public void notifyElementPut(Ehcache cache, Element element) throws CacheException {
this.getDelegate().notifyElementPut(cache, element);
}
@Override
public void notifyElementUpdated(Ehcache cache, Element element) throws CacheException {
this.getDelegate().notifyElementUpdated(cache, element);
}
@Override
public void notifyElementExpired(Ehcache cache, Element element) {
this.getDelegate().notifyElementExpired(cache, element);
}
@Override
public void notifyElementEvicted(Ehcache cache, Element element) {
this.getDelegate().notifyElementEvicted(cache, element);
}
@Override
public void notifyRemoveAll(Ehcache cache) {
this.getDelegate().notifyRemoveAll(cache);
}
@Override
public void dispose() {
this.getDelegate().dispose();
this.delegate = null;
}
@Override
public Object clone() throws CloneNotSupportedException {
return new LazyCacheEventListener(beanName);
}
}
}