Java tutorial
/* * Copyright 2013-2014 the original author or authors. * * 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 org.springframework.batch.core.jsr.configuration.xml; import java.util.Enumeration; import java.util.HashMap; import java.util.Map; import java.util.Properties; import java.util.regex.Matcher; import java.util.regex.Pattern; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.springframework.batch.core.jsr.configuration.support.JsrExpressionParser; import org.springframework.beans.factory.config.BeanDefinition; import org.springframework.beans.factory.support.AbstractBeanDefinition; import org.springframework.beans.factory.support.BeanDefinitionBuilder; import org.springframework.beans.factory.support.BeanDefinitionRegistry; import org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader; import org.springframework.util.ClassUtils; import org.w3c.dom.Element; import org.w3c.dom.NamedNodeMap; import org.w3c.dom.Node; import org.w3c.dom.NodeList; import org.w3c.dom.ls.DOMImplementationLS; import org.w3c.dom.traversal.DocumentTraversal; import org.w3c.dom.traversal.NodeFilter; import org.w3c.dom.traversal.NodeIterator; /** * <p> * {@link DefaultBeanDefinitionDocumentReader} extension to hook into the pre processing of the provided * XML document, ensuring any references to property operators such as jobParameters and jobProperties are * resolved prior to loading the context. Since we know these initial values upfront, doing this transformation * allows us to ensure values are retrieved in their resolved form prior to loading the context and property * operators can be used on any element. This document reader will also look for references to artifacts by * the same name and create new bean definitions to provide the ability to create new instances. * </p> * * @author Chris Schaefer * @since 3.0 */ public class JsrBeanDefinitionDocumentReader extends DefaultBeanDefinitionDocumentReader { private static final String NULL = "null"; private static final String ROOT_JOB_ELEMENT_NAME = "job"; private static final String JOB_PROPERTY_ELEMENT_NAME = "property"; private static final String JOB_PROPERTIES_ELEMENT_NAME = "properties"; private static final String JOB_PROPERTY_ELEMENT_NAME_ATTRIBUTE = "name"; private static final String JOB_PROPERTY_ELEMENT_VALUE_ATTRIBUTE = "value"; private static final String JOB_PROPERTIES_KEY_NAME = "jobProperties"; private static final String JOB_PARAMETERS_KEY_NAME = "jobParameters"; private static final String JOB_PARAMETERS_BEAN_DEFINITION_NAME = "jsr_jobParameters"; private static final Log LOG = LogFactory.getLog(JsrBeanDefinitionDocumentReader.class); private static final Pattern PROPERTY_KEY_SEPERATOR = Pattern.compile("'([^']*?)'"); private static final Pattern OPERATOR_PATTERN = Pattern.compile("(#\\{(job(Properties|Parameters))[^}]+\\})"); private BeanDefinitionRegistry beanDefinitionRegistry; private JsrExpressionParser expressionParser = new JsrExpressionParser(); private Map<String, Properties> propertyMap = new HashMap<String, Properties>(); /** * <p> * Creates a new {@link JsrBeanDefinitionDocumentReader} instance. * </p> */ public JsrBeanDefinitionDocumentReader() { } /** * <p> * Create a new {@link JsrBeanDefinitionDocumentReader} instance with the provided * {@link BeanDefinitionRegistry}. * </p> * * @param beanDefinitionRegistry the {@link BeanDefinitionRegistry} to use */ public JsrBeanDefinitionDocumentReader(BeanDefinitionRegistry beanDefinitionRegistry) { this.beanDefinitionRegistry = beanDefinitionRegistry; } @Override protected void preProcessXml(Element root) { if (ROOT_JOB_ELEMENT_NAME.equals(root.getLocalName())) { initProperties(root); transformDocument(root); if (LOG.isDebugEnabled()) { LOG.debug("Transformed XML from preProcessXml: " + elementToString(root)); } } } protected void initProperties(Element root) { propertyMap.put(JOB_PARAMETERS_KEY_NAME, initJobParameters()); propertyMap.put(JOB_PROPERTIES_KEY_NAME, initJobProperties(root)); resolvePropertyValues(propertyMap.get(JOB_PARAMETERS_KEY_NAME)); resolvePropertyValues(propertyMap.get(JOB_PROPERTIES_KEY_NAME)); } private Properties initJobParameters() { Properties jobParameters = new Properties(); if (getBeanDefinitionRegistry().containsBeanDefinition(JOB_PARAMETERS_BEAN_DEFINITION_NAME)) { BeanDefinition beanDefintion = getBeanDefinitionRegistry() .getBeanDefinition(JOB_PARAMETERS_BEAN_DEFINITION_NAME); Properties properties = (Properties) beanDefintion.getConstructorArgumentValues() .getGenericArgumentValue(Properties.class).getValue(); if (properties == null) { return new Properties(); } Enumeration<?> propertyNames = properties.propertyNames(); while (propertyNames.hasMoreElements()) { String curName = (String) propertyNames.nextElement(); jobParameters.put(curName, properties.getProperty(curName)); } } return jobParameters; } private Properties initJobProperties(Element root) { Properties properties = new Properties(); Node propertiesNode = root.getElementsByTagName(JOB_PROPERTIES_ELEMENT_NAME).item(0); if (propertiesNode != null) { NodeList children = propertiesNode.getChildNodes(); for (int i = 0; i < children.getLength(); i++) { Node child = children.item(i); if (JOB_PROPERTY_ELEMENT_NAME.equals(child.getLocalName())) { NamedNodeMap attributes = child.getAttributes(); Node name = attributes.getNamedItem(JOB_PROPERTY_ELEMENT_NAME_ATTRIBUTE); Node value = attributes.getNamedItem(JOB_PROPERTY_ELEMENT_VALUE_ATTRIBUTE); properties.setProperty(name.getNodeValue(), value.getNodeValue()); } } } return properties; } private void resolvePropertyValues(Properties properties) { for (String propertyKey : properties.stringPropertyNames()) { String resolvedPropertyValue = resolvePropertyValue(properties.getProperty(propertyKey)); if (!properties.getProperty(propertyKey).equals(resolvedPropertyValue)) { properties.setProperty(propertyKey, resolvedPropertyValue); } } } private String resolvePropertyValue(String propertyValue) { String resolvedValue = resolveValue(propertyValue); Matcher jobParameterMatcher = OPERATOR_PATTERN.matcher(resolvedValue); while (jobParameterMatcher.find()) { resolvedValue = resolvePropertyValue(resolvedValue); } return resolvedValue; } private String resolveValue(String value) { StringBuffer valueBuffer = new StringBuffer(); Matcher jobParameterMatcher = OPERATOR_PATTERN.matcher(value); while (jobParameterMatcher.find()) { Matcher jobParameterKeyMatcher = PROPERTY_KEY_SEPERATOR.matcher(jobParameterMatcher.group(1)); if (jobParameterKeyMatcher.find()) { String propertyType = jobParameterMatcher.group(2); String extractedProperty = jobParameterKeyMatcher.group(1); Properties properties = propertyMap.get(propertyType); if (properties == null) { throw new IllegalArgumentException("Unknown property type: " + propertyType); } String resolvedProperty = properties.getProperty(extractedProperty, NULL); if (NULL.equals(resolvedProperty)) { LOG.info(propertyType + " with key of: " + extractedProperty + " could not be resolved. Possible configuration error?"); } jobParameterMatcher.appendReplacement(valueBuffer, resolvedProperty); } } jobParameterMatcher.appendTail(valueBuffer); String resolvedValue = valueBuffer.toString(); if (NULL.equals(resolvedValue)) { return ""; } return expressionParser.parseExpression(resolvedValue); } private BeanDefinitionRegistry getBeanDefinitionRegistry() { return beanDefinitionRegistry != null ? beanDefinitionRegistry : getReaderContext().getRegistry(); } private void transformDocument(Element root) { DocumentTraversal traversal = (DocumentTraversal) root.getOwnerDocument(); NodeIterator iterator = traversal.createNodeIterator(root, NodeFilter.SHOW_ELEMENT, null, true); BeanDefinitionRegistry registry = getBeanDefinitionRegistry(); Map<String, Integer> referenceCountMap = new HashMap<String, Integer>(); for (Node n = iterator.nextNode(); n != null; n = iterator.nextNode()) { NamedNodeMap map = n.getAttributes(); if (map.getLength() > 0) { for (int i = 0; i < map.getLength(); i++) { Node node = map.item(i); String nodeName = node.getNodeName(); String nodeValue = node.getNodeValue(); String resolvedValue = resolveValue(nodeValue); String newNodeValue = resolvedValue; if ("ref".equals(nodeName)) { if (!referenceCountMap.containsKey(resolvedValue)) { referenceCountMap.put(resolvedValue, 0); } boolean isClass = isClass(resolvedValue); Integer referenceCount = referenceCountMap.get(resolvedValue); // possibly fully qualified class name in ref tag in the JSL or pointer to bean/artifact ref. if (isClass && !registry.containsBeanDefinition(resolvedValue)) { AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder .genericBeanDefinition(resolvedValue).getBeanDefinition(); beanDefinition.setScope("step"); registry.registerBeanDefinition(resolvedValue, beanDefinition); newNodeValue = resolvedValue; } else { if (registry.containsBeanDefinition(resolvedValue)) { referenceCount++; referenceCountMap.put(resolvedValue, referenceCount); newNodeValue = resolvedValue + referenceCount; BeanDefinition beanDefinition = registry.getBeanDefinition(resolvedValue); registry.registerBeanDefinition(newNodeValue, beanDefinition); } } } if (!nodeValue.equals(newNodeValue)) { node.setNodeValue(newNodeValue); } } } else { String nodeValue = n.getTextContent(); String resolvedValue = resolveValue(nodeValue); if (!nodeValue.equals(resolvedValue)) { n.setTextContent(resolvedValue); } } } } private boolean isClass(String className) { try { Class.forName(className, false, ClassUtils.getDefaultClassLoader()); } catch (ClassNotFoundException e) { return false; } return true; } protected Properties getJobParameters() { return propertyMap.get(JOB_PARAMETERS_KEY_NAME); } protected Properties getJobProperties() { return propertyMap.get(JOB_PROPERTIES_KEY_NAME); } private String elementToString(Element root) { DOMImplementationLS domImplLS = (DOMImplementationLS) root.getOwnerDocument().getImplementation(); return domImplLS.createLSSerializer().writeToString(root); } }