org.springmodules.cache.config.AbstractCacheProviderFacadeParser.java Source code

Introduction

Here is the source code for org.springmodules.cache.config.AbstractCacheProviderFacadeParser.java

Source

/* 
 * Created on Jan 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 org.w3c.dom.Element;

import org.springframework.beans.MutablePropertyValues;
import org.springframework.beans.PropertyValue;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.RootBeanDefinition;
import org.springframework.beans.factory.xml.BeanDefinitionParser;
import org.springframework.beans.factory.xml.ParserContext;
import org.springframework.util.StringUtils;

import org.springmodules.cache.serializable.XStreamSerializableFactory;

/**
 * <p>
 * Template that handles the parsing of the XML tag "config". Creates and
 * registers and implementation of
 * <code>{@link org.springmodules.cache.provider.CacheProviderFacade}</code>
 * in the provided registry of bean definitions.
 * </p>
 * 
 * @author Alex Ruiz
 */
public abstract class AbstractCacheProviderFacadeParser implements BeanDefinitionParser {

    /**
     * Contains the names of the bean properties used in this parser.
     */
    private static abstract class PropertyName {

        static final String SERIALIZABLE_FACTORY = "serializableFactory";
    }

    /**
     * Contains the valid values for the XML element
     * <code>serializableFactory</code>.
     */
    private static abstract class SerializableFactory {

        static final String NONE = "NONE";

        static final String XSTREAM = "XSTREAM";
    }

    /**
     * Parses the specified XML element which contains the properties of the
     * <code>{@link org.springmodules.cache.provider.CacheProviderFacade}</code>
     * to register in the given registry of bean definitions.
     * 
     * @param element
     *          the XML element to parse
     * @param parserContext
     *          the parser context
     * @throws IllegalStateException
     *           if the value of the property <code>serializableFactory</code>
     *           is not equal to "NONE" or "XSTREAM"
     * 
     * @see BeanDefinitionParser#parse(Element, ParserContext)
     */
    public final BeanDefinition parse(Element element, ParserContext parserContext) throws IllegalStateException {
        String id = element.getAttribute("id");

        // create the cache provider facade
        Class clazz = getCacheProviderFacadeClass();
        MutablePropertyValues propertyValues = new MutablePropertyValues();
        RootBeanDefinition cacheProviderFacade = new RootBeanDefinition(clazz, propertyValues);
        propertyValues.addPropertyValue(parseFailQuietlyEnabledProperty(element));
        propertyValues.addPropertyValue(parseSerializableFactoryProperty(element));

        BeanDefinitionRegistry registry = parserContext.getRegistry();
        registry.registerBeanDefinition(id, cacheProviderFacade);

        doParse(id, element, registry);
        return null;
    }

    /**
     * Gives subclasses (of this class) the opportunity to parse their own bean
     * definitions.
     * 
     * @param cacheProviderFacadeId
     *          the id of the already registered <code>CacheProviderFacade</code>
     * @param element
     *          the XML element containing the values needed to parse bean
     *          definitions
     * @param registry
     *          the registry of bean definitions
     */
    protected void doParse(String cacheProviderFacadeId, Element element, BeanDefinitionRegistry registry) {
        // no implementation.
    }

    /**
     * @return the class of the <code>CacheProviderFacade</code> to register.
     */
    protected abstract Class getCacheProviderFacadeClass();

    /**
     * Parses the given XML element to obtain the value of the property
     * <code>failQuietly</code>. This property specifies if any exception
     * thrown at run-time by the cache should be propagated (<code>false</code>)
     * to the application or not (<code>true</code>.)
     * 
     * @param element
     *          the XML element to parse
     * @return the value of the property <code>failQuietly</code>
     */
    private PropertyValue parseFailQuietlyEnabledProperty(Element element) {
        String failQuietlyAttr = element.getAttribute("failQuietly");
        Boolean value = "true".equalsIgnoreCase(failQuietlyAttr) ? Boolean.TRUE : Boolean.FALSE;
        return new PropertyValue("failQuietlyEnabled", value);
    }

    /**
     * Parses the given XML element to obtain the value of the property
     * <code>serializableFactory</code>. This property specify the factory that
     * forces cache entries to implement the interface <code>Serializable</code>.
     * 
     * @param element
     *          the XML element to parse
     * @return the value of the property <code>serializableFactory</code>
     * @throws IllegalStateException
     *           if the value of the property <code>serializableFactory</code>
     *           is not equal to "NONE" or "XSTREAM"
     */
    private PropertyValue parseSerializableFactoryProperty(Element element) throws IllegalStateException {
        String serializableFactoryAttr = element.getAttribute("serializableFactory");

        if (!StringUtils.hasText(serializableFactoryAttr)
                || SerializableFactory.NONE.equalsIgnoreCase(serializableFactoryAttr)) {
            return new PropertyValue(PropertyName.SERIALIZABLE_FACTORY, null);
        }

        if (SerializableFactory.XSTREAM.equalsIgnoreCase(serializableFactoryAttr)) {
            return new PropertyValue(PropertyName.SERIALIZABLE_FACTORY, new XStreamSerializableFactory());
        }

        throw new IllegalStateException(
                StringUtils.quote(serializableFactoryAttr) + " is not a serializableFactory. Valid values include "
                        + StringUtils.quote(SerializableFactory.NONE) + " and "
                        + StringUtils.quote(SerializableFactory.XSTREAM));
    }
}