/*
* Created on Feb 19, 2006
*
* Licensed 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.
*
* Copyright @2006 the original author or authors.
*/
package org.springmodules.cache.config;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.w3c.dom.Element;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.RuntimeBeanReference;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.ManagedList;
import org.springframework.beans.factory.xml.BeanDefinitionParser;
import org.springframework.beans.factory.xml.ParserContext;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;
import org.springframework.util.xml.DomUtils;
import org.springmodules.cache.CachingModel;
import org.springmodules.cache.FlushingModel;
/**
* <p>
* Template that handles the parsing of setup strategy for declarative caching
* services.
* </p>
*
* @author Alex Ruiz
*/
public abstract class AbstractCacheSetupStrategyParser implements
BeanDefinitionParser {
private BeanReferenceParser beanReferenceParser;
private CacheModelParser cacheModelParser;
private CachingListenerValidator cachingListenerValidator;
/**
* Constructor.
*/
public AbstractCacheSetupStrategyParser() {
super();
beanReferenceParser = new BeanReferenceParserImpl();
cachingListenerValidator = new CachingListenerValidatorImpl();
}
/**
* Parses the given XML element containing the properties and/or sub-elements
* necessary to configure a strategy for setting up declarative caching
* services.
*
* @param element
* the XML element to parse
* @param parserContext
* the parser context
* @throws IllegalStateException
* if the bean definition registry does not have a definition for
* the <code>CacheProviderFacade</code> registered under the name
* specified in the XML attribute "providerId"
* @throws IllegalStateException
* if the cache provider facade is in invalid state
* @throws IllegalStateException
* if any of the caching listeners is not an instance of
* <code>CachingListener</code>
*
* @see BeanDefinitionParser#parse(Element, ParserContext)
*/
public final BeanDefinition parse(Element element, ParserContext parserContext)
throws NoSuchBeanDefinitionException, IllegalStateException {
String cacheProviderFacadeId = element.getAttribute("providerId");
BeanDefinitionRegistry registry = parserContext.getRegistry();
if (!registry.containsBeanDefinition(cacheProviderFacadeId)) {
throw new IllegalStateException(
"An implementation of CacheProviderFacade should be registered under the name "
+ StringUtils.quote(cacheProviderFacadeId));
}
RuntimeBeanReference cacheProviderFacadeReference = new RuntimeBeanReference(
cacheProviderFacadeId);
Object cacheKeyGenerator = parseCacheKeyGenerator(element, parserContext);
List cachingListeners = parseCachingListeners(element, parserContext);
Map cachingModels = parseCachingModels(element);
Map flushingModels = parseFlushingModels(element);
CacheSetupStrategyPropertySource ps = new CacheSetupStrategyPropertySource(
cacheKeyGenerator, cacheProviderFacadeReference, cachingListeners,
cachingModels, flushingModels);
parseCacheSetupStrategy(element, parserContext, ps);
return null;
}
public final void setCacheModelParser(CacheModelParser newCacheModelParser) {
cacheModelParser = newCacheModelParser;
}
protected final BeanReferenceParser getBeanReferenceParser() {
return beanReferenceParser;
}
/**
* Returns the key to be used to store a
* <code>{@link org.springmodules.cache.CacheModel}</code> in a map. Each
* implementation of this class has two maps, one for caching models and one
* for flushing models. The key of each model is specified by each
* implementation of this template.
*
* @return the key to be used to store a <code>CacheModel</code> in a map
*/
protected abstract String getCacheModelKey();
protected final CacheModelParser getCacheModelParser() {
return cacheModelParser;
}
/**
* Parses the given XML element to create the strategy for setting up
* declarative caching services.
*
* @param element
* the XML element to parse
* @param parserContext
* the parser context
* @param propertySource
* contains common properties for the different cache setup
* strategies
*/
protected abstract void parseCacheSetupStrategy(Element element,
ParserContext parserContext,
CacheSetupStrategyPropertySource propertySource);
protected final void setBeanReferenceParser(
BeanReferenceParser newBeanReferenceParser) {
beanReferenceParser = newBeanReferenceParser;
}
protected final void setCachingListenerValidator(
CachingListenerValidator newCachingListenerValidator) {
cachingListenerValidator = newCachingListenerValidator;
}
private Object parseCacheKeyGenerator(Element element,
ParserContext parserContext) {
Object keyGenerator = null;
List cacheKeyGeneratorElements = DomUtils.getChildElementsByTagName(
element, "cacheKeyGenerator");
if (!CollectionUtils.isEmpty(cacheKeyGeneratorElements)) {
Element cacheKeyGeneratorElement = (Element) cacheKeyGeneratorElements
.get(0);
keyGenerator = beanReferenceParser.parse(cacheKeyGeneratorElement,
parserContext);
}
return keyGenerator;
}
/**
* Parses the given XML element containing references to the caching listeners
* to be added to the caching setup strategy.
*
* @param element
* the XML element to parse
* @param parserContext
* the parser context
* @return a list containing references to caching listeners already
* registered in the given register
* @throws IllegalStateException
* if any of the given ids reference a caching listener that does
* not exist in the registry
* @throws IllegalStateException
* if the given id references a caching listener that is not an
* instance of <code>CachingListener</code>
* @throws IllegalStateException
* if the caching listener elements does not contain a reference to
* an existing caching listener and does not contain an inner
* definition of a caching listener
*/
private List parseCachingListeners(Element element,
ParserContext parserContext) throws IllegalStateException {
List listenersElements = DomUtils.getChildElementsByTagName(element,
"cachingListeners");
if (CollectionUtils.isEmpty(listenersElements)) {
return null;
}
Element listenersElement = (Element) listenersElements.get(0);
List listenerElements = DomUtils.getChildElementsByTagName(
listenersElement, "cachingListener");
ManagedList listeners = new ManagedList();
boolean registerCachingListener = true;
int listenerCount = listenerElements.size();
for (int i = 0; i < listenerCount; i++) {
Element listenerElement = (Element) listenerElements.get(i);
Object cachingListener = beanReferenceParser.parse(listenerElement,
parserContext, registerCachingListener);
cachingListenerValidator.validate(cachingListener, i, parserContext);
listeners.add(cachingListener);
}
return listeners;
}
/**
* Parses the given XML element which sub-elements containing the properties
* of the caching models to create.
*
* @param element
* the XML element to parse
* @return a map containing the parsed caching models.The key of each element
* is the value of the XML attribute <code>target</code> (a String)
* and the value is the caching model (an instance of
* <code>CachingModel</code>)
*/
private Map parseCachingModels(Element element) {
List modelElements = DomUtils.getChildElementsByTagName(element, "caching");
if (CollectionUtils.isEmpty(modelElements)) {
return null;
}
String cacheModelKey = getCacheModelKey();
Map models = new HashMap();
int modelElementCount = modelElements.size();
for (int i = 0; i < modelElementCount; i++) {
Element modelElement = (Element) modelElements.get(i);
String key = modelElement.getAttribute(cacheModelKey);
CachingModel model = cacheModelParser.parseCachingModel(modelElement);
models.put(key, model);
}
return models;
}
/**
* Parses the given XML element which sub-elements containing the properties
* of the flushing models to create.
*
* @param element
* the XML element to parse
* @return a map containing the parsed flushing models.The key of each element
* is the value of the XML attribute <code>target</code> (a String) *
* and the value is the flushing model (an instance of
* <code>FlushingModel</code>)
*/
private Map parseFlushingModels(Element element) {
List modelElements = DomUtils.getChildElementsByTagName(element,
"flushing");
if (CollectionUtils.isEmpty(modelElements)) {
return null;
}
String cacheModelKey = getCacheModelKey();
Map models = new HashMap();
int modelElementCount = modelElements.size();
for (int i = 0; i < modelElementCount; i++) {
Element modelElement = (Element) modelElements.get(i);
String key = modelElement.getAttribute(cacheModelKey);
FlushingModel model = cacheModelParser.parseFlushingModel(modelElement);
models.put(key, model);
}
return models;
}
}