net.scriptability.core.integration.spring.ScriptAbilityBeanDefinitionParser.java Source code

Introduction

Here is the source code for net.scriptability.core.integration.spring.ScriptAbilityBeanDefinitionParser.java

Source

/*
 * Copyright 2013 Hayden Bakkum
 *
 *  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.
 */

package net.scriptability.core.integration.spring;

import com.google.common.base.Preconditions;
import com.google.common.base.Strings;
import net.scriptability.core.ScriptAbility;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.MethodInvokingFactoryBean;
import org.springframework.beans.factory.config.RuntimeBeanReference;
import org.springframework.beans.factory.support.*;
import org.springframework.beans.factory.xml.AbstractBeanDefinitionParser;
import org.springframework.beans.factory.xml.ParserContext;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;

import java.util.List;
import java.util.Map;

/**
 * Parses ScriptAbility custom spring XML namespace configuration into a {@link BeanDefinition}
 *
 * @author Hayden Bakkum
 */
public class ScriptAbilityBeanDefinitionParser extends AbstractBeanDefinitionParser {

    private static final String XML_NAMESPACE__SCRIPTABILITY = "http://www.scriptability.net/schema/scriptability";

    private static final String XML_ELEMENT__CONFIGURE = "configure";
    private static final String XML_ELEMENT__BINDINGS = "bindings";
    private static final String XML_ELEMENT__BINDING = "binding";

    private static final String XML_ATTRIBUTE__ID = "id";
    private static final String XML_ATTRIBUTE__CONFIGURATION_LOADER = "configurationLoader";
    private static final String XML_ATTRIBUTE__EVENT_SCHEDULER = "eventScheduler";
    private static final String XML_ATTRIBUTE__NAME = "name";
    private static final String XML_ATTRIBUTE__BEAN_REF = "beanRef";

    private static final String DEFAULT_SCRIPTABILITY_BEAN_NAME = "scriptability";

    @Override
    protected AbstractBeanDefinition parseInternal(final Element element, final ParserContext parserContext) {
        Preconditions.checkArgument(XML_ELEMENT__CONFIGURE.equals(element.getLocalName()),
                "Expected element tag: %s", XML_ELEMENT__CONFIGURE);

        BeanDefinitionRegistry beanDefinitionRegistry = parserContext.getRegistry();

        String factoryBeanName = registerScriptAbilityFactoryBean(element, beanDefinitionRegistry);
        registerScriptAbilityInitialisingBean(element, factoryBeanName, beanDefinitionRegistry);

        BeanDefinitionBuilder builder = BeanDefinitionBuilder
                .genericBeanDefinition(MethodInvokingFactoryBean.class);
        builder.addPropertyValue("targetClass", ScriptAbility.class);
        builder.addPropertyValue("targetMethod", "getScriptAbility");

        return builder.getBeanDefinition();
    }

    @Override
    protected String resolveId(Element element, AbstractBeanDefinition definition, ParserContext parserContext) {
        String id = element.getAttribute(XML_ATTRIBUTE__ID);
        if (Strings.isNullOrEmpty(id)) {
            return DEFAULT_SCRIPTABILITY_BEAN_NAME;
        } else {
            return id;
        }
    }

    private String registerScriptAbilityFactoryBean(final Element configureElement,
            final BeanDefinitionRegistry beanDefinitionRegistry) {
        BeanDefinitionBuilder builder = BeanDefinitionBuilder
                .genericBeanDefinition(SpringScriptAbilityFactory.class);
        if (configureElement.hasAttribute(XML_ATTRIBUTE__CONFIGURATION_LOADER)) {
            builder.addPropertyReference("configurationLoader",
                    configureElement.getAttribute(XML_ATTRIBUTE__CONFIGURATION_LOADER));
        }
        if (configureElement.hasAttribute(XML_ATTRIBUTE__EVENT_SCHEDULER)) {
            builder.addPropertyReference("eventScheduler",
                    configureElement.getAttribute(XML_ATTRIBUTE__EVENT_SCHEDULER));
        }
        return BeanDefinitionReaderUtils.registerWithGeneratedName(builder.getBeanDefinition(),
                beanDefinitionRegistry);
    }

    private String registerScriptAbilityInitialisingBean(final Element configureElement,
            final String factoryBeanName, final BeanDefinitionRegistry beanDefinitionRegistry) {
        BeanDefinitionBuilder builder = BeanDefinitionBuilder
                .genericBeanDefinition(MethodInvokingFactoryBean.class);
        builder.addPropertyReference("targetObject", DEFAULT_SCRIPTABILITY_BEAN_NAME);
        builder.addPropertyValue("targetMethod", "start");

        List<Object> arguments = new ManagedList();
        if (hasBindingsElement(configureElement)) {
            Map<String, RuntimeBeanReference> bindings = createBeanBindings((Element) configureElement
                    .getElementsByTagNameNS(XML_NAMESPACE__SCRIPTABILITY, XML_ELEMENT__BINDINGS).item(0));
            arguments.add(bindings);
        }
        arguments.add(new RuntimeBeanReference(factoryBeanName));
        builder.addPropertyValue("arguments", arguments);

        return BeanDefinitionReaderUtils.registerWithGeneratedName(builder.getBeanDefinition(),
                beanDefinitionRegistry);
    }

    private Map<String, RuntimeBeanReference> createBeanBindings(final Element bindingsElement) {
        Map<String, RuntimeBeanReference> beanBindings = new ManagedMap<>();
        NodeList bindingNodeList = bindingsElement.getElementsByTagNameNS(XML_NAMESPACE__SCRIPTABILITY,
                XML_ELEMENT__BINDING);
        for (int i = 0; i < bindingNodeList.getLength(); i++) {
            Element binding = (Element) bindingNodeList.item(i);
            beanBindings.put(binding.getAttribute(XML_ATTRIBUTE__NAME),
                    new RuntimeBeanReference(binding.getAttribute(XML_ATTRIBUTE__BEAN_REF)));
        }
        return beanBindings;
    }

    private boolean hasBindingsElement(final Element element) {
        return element.getElementsByTagNameNS(XML_NAMESPACE__SCRIPTABILITY, XML_ELEMENT__BINDINGS).getLength() > 0;
    }

}