001 /** 002 * Licensed to the Apache Software Foundation (ASF) under one or more 003 * contributor license agreements. See the NOTICE file distributed with 004 * this work for additional information regarding copyright ownership. 005 * The ASF licenses this file to You under the Apache License, Version 2.0 006 * (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software 012 * distributed under the License is distributed on an "AS IS" BASIS, 013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 014 * See the License for the specific language governing permissions and 015 * limitations under the License. 016 */ 017 package org.apache.camel.spring.handler; 018 019 import java.util.HashMap; 020 import java.util.HashSet; 021 import java.util.Map; 022 import java.util.Set; 023 024 import javax.xml.bind.Binder; 025 import javax.xml.bind.JAXBContext; 026 import javax.xml.bind.JAXBException; 027 028 import org.w3c.dom.Element; 029 import org.w3c.dom.Node; 030 import org.w3c.dom.NodeList; 031 032 import org.apache.camel.ExchangePattern; 033 import org.apache.camel.builder.xml.Namespaces; 034 import org.apache.camel.spi.NamespaceAware; 035 import org.apache.camel.spring.CamelBeanPostProcessor; 036 import org.apache.camel.spring.CamelContextFactoryBean; 037 import org.apache.camel.spring.CamelJMXAgentType; 038 import org.apache.camel.spring.CamelTemplateFactoryBean; 039 import org.apache.camel.spring.EndpointFactoryBean; 040 import org.apache.camel.spring.remoting.CamelProxyFactoryBean; 041 import org.apache.camel.spring.remoting.CamelServiceExporter; 042 import org.apache.camel.util.ObjectHelper; 043 import org.apache.camel.view.ModelFileGenerator; 044 import org.apache.commons.logging.Log; 045 import org.apache.commons.logging.LogFactory; 046 import org.springframework.beans.factory.BeanDefinitionStoreException; 047 import org.springframework.beans.factory.config.BeanDefinition; 048 import org.springframework.beans.factory.config.RuntimeBeanReference; 049 import org.springframework.beans.factory.parsing.BeanComponentDefinition; 050 import org.springframework.beans.factory.support.BeanDefinitionBuilder; 051 import org.springframework.beans.factory.xml.NamespaceHandlerSupport; 052 import org.springframework.beans.factory.xml.ParserContext; 053 054 /** 055 * Camel namespace for the spring XML configuration file. 056 */ 057 public class CamelNamespaceHandler extends NamespaceHandlerSupport { 058 059 private static final transient Log LOG = LogFactory.getLog(CamelNamespaceHandler.class); 060 protected BeanDefinitionParser endpointParser = new BeanDefinitionParser(EndpointFactoryBean.class); 061 protected BeanDefinitionParser beanPostProcessorParser = new BeanDefinitionParser(CamelBeanPostProcessor.class); 062 protected Set<String> parserElementNames = new HashSet<String>(); 063 protected Binder<Node> binder; 064 private JAXBContext jaxbContext; 065 private Map<String, BeanDefinitionParser> parserMap = new HashMap<String, BeanDefinitionParser>(); 066 067 public ModelFileGenerator createModelFileGenerator() throws JAXBException { 068 return new ModelFileGenerator(getJaxbContext()); 069 } 070 071 public void init() { 072 // remoting 073 addBeanDefinitionParser("proxy", CamelProxyFactoryBean.class); 074 addBeanDefinitionParser("template", CamelTemplateFactoryBean.class); 075 addBeanDefinitionParser("export", CamelServiceExporter.class); 076 077 // jmx agent 078 addBeanDefinitionParser("jmxAgent", CamelJMXAgentType.class); 079 080 // TODO switch to use the above mechanism? 081 registerParser("endpoint", endpointParser); 082 083 boolean osgi = false; 084 Class cl = CamelContextFactoryBean.class; 085 try { 086 cl = Class.forName("org.apache.camel.osgi.CamelContextFactoryBean"); 087 osgi = true; 088 } catch (Throwable t) { 089 LOG.trace("Cannot find class so assuming not running in OSGI container: " + t.getMessage()); 090 } 091 092 if (osgi) { 093 LOG.info("camel-osgi.jar detected in classpath"); 094 } else { 095 LOG.info("camel-osgi.jar not detected in classpath"); 096 } 097 098 if (LOG.isDebugEnabled()) { 099 LOG.debug("Using " + cl.getCanonicalName() + " as CamelContextBeanDefinitionParser"); 100 } 101 registerParser("camelContext", new CamelContextBeanDefinitionParser(cl)); 102 } 103 104 private void addBeanDefinitionParser(String elementName, Class<?> type) { 105 BeanDefinitionParser parser = new BeanDefinitionParser(type); 106 registerParser(elementName, parser); 107 parserMap.put(elementName, parser); 108 } 109 110 protected void createBeanPostProcessor(ParserContext parserContext, String contextId, Element childElement, BeanDefinitionBuilder parentBuilder) { 111 String beanPostProcessorId = contextId + ":beanPostProcessor"; 112 childElement.setAttribute("id", beanPostProcessorId); 113 BeanDefinition definition = beanPostProcessorParser.parse(childElement, parserContext); 114 // only register to camel context id as a String. Then we can look it up later 115 // otherwise we get a circular reference in spring and it will not allow custom bean post processing 116 // see more at CAMEL-1663 117 definition.getPropertyValues().addPropertyValue("camelId", contextId); 118 parentBuilder.addPropertyReference("beanPostProcessor", beanPostProcessorId); 119 } 120 121 protected void registerScriptParser(String elementName, String engineName) { 122 registerParser(elementName, new ScriptDefinitionParser(engineName)); 123 } 124 125 protected void registerParser(String name, 126 org.springframework.beans.factory.xml.BeanDefinitionParser parser) { 127 parserElementNames.add(name); 128 registerBeanDefinitionParser(name, parser); 129 } 130 131 public Set<String> getParserElementNames() { 132 return parserElementNames; 133 } 134 135 protected Object parseUsingJaxb(Element element, ParserContext parserContext) { 136 try { 137 binder = getJaxbContext().createBinder(); 138 return binder.unmarshal(element); 139 /* 140 * Unmarshaller unmarshaller = 141 * getJaxbContext().createUnmarshaller(); return 142 * unmarshaller.unmarshal(element); 143 */ 144 } catch (JAXBException e) { 145 throw new BeanDefinitionStoreException("Failed to parse JAXB element: " + e, e); 146 } 147 } 148 149 public JAXBContext getJaxbContext() throws JAXBException { 150 if (jaxbContext == null) { 151 jaxbContext = createJaxbContext(); 152 } 153 return jaxbContext; 154 } 155 156 protected JAXBContext createJaxbContext() throws JAXBException { 157 StringBuilder packages = new StringBuilder(); 158 for (Class cl : getJaxbPackages()) { 159 if (packages.length() > 0) { 160 packages.append(":"); 161 } 162 packages.append(cl.getName().substring(0, cl.getName().lastIndexOf('.'))); 163 } 164 return JAXBContext.newInstance(packages.toString(), getClass().getClassLoader()); 165 } 166 167 protected Set<Class> getJaxbPackages() { 168 Set<Class> classes = new HashSet<Class>(); 169 classes.add(org.apache.camel.spring.CamelContextFactoryBean.class); 170 classes.add(ExchangePattern.class); 171 classes.add(org.apache.camel.model.RouteType.class); 172 classes.add(org.apache.camel.model.config.StreamResequencerConfig.class); 173 classes.add(org.apache.camel.model.dataformat.DataFormatType.class); 174 classes.add(org.apache.camel.model.language.ExpressionType.class); 175 classes.add(org.apache.camel.model.loadbalancer.LoadBalancerType.class); 176 return classes; 177 } 178 179 protected class CamelContextBeanDefinitionParser extends BeanDefinitionParser { 180 public CamelContextBeanDefinitionParser(Class type) { 181 super(type); 182 } 183 184 @Override 185 protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) { 186 super.doParse(element, parserContext, builder); 187 188 String contextId = element.getAttribute("id"); 189 190 // lets avoid folks having to explicitly give an ID to a camel 191 // context 192 if (ObjectHelper.isNullOrBlank(contextId)) { 193 contextId = "camelContext"; 194 element.setAttribute("id", contextId); 195 } 196 197 // now lets parse the routes with JAXB 198 Object value = parseUsingJaxb(element, parserContext); 199 200 if (value instanceof CamelContextFactoryBean) { 201 // set the property value with the JAXB parsed value 202 CamelContextFactoryBean factoryBean = (CamelContextFactoryBean)value; 203 builder.addPropertyValue("id", contextId); 204 builder.addPropertyValue("routes", factoryBean.getRoutes()); 205 builder.addPropertyValue("intercepts", factoryBean.getIntercepts()); 206 builder.addPropertyValue("dataFormats", factoryBean.getDataFormats()); 207 builder.addPropertyValue("builderRefs", factoryBean.getBuilderRefs()); 208 builder.addPropertyValue("properties", factoryBean.getProperties()); 209 if (factoryBean.getPackages().length > 0) { 210 builder.addPropertyValue("packages", factoryBean.getPackages()); 211 } 212 } 213 214 boolean createdBeanPostProcessor = false; 215 NodeList list = element.getChildNodes(); 216 int size = list.getLength(); 217 for (int i = 0; i < size; i++) { 218 Node child = list.item(i); 219 if (child instanceof Element) { 220 Element childElement = (Element)child; 221 String localName = child.getLocalName(); 222 if (localName.equals("beanPostProcessor")) { 223 createBeanPostProcessor(parserContext, contextId, childElement, builder); 224 createdBeanPostProcessor = true; 225 } else if (localName.equals("endpoint")) { 226 BeanDefinition definition = endpointParser.parse(childElement, parserContext); 227 String id = childElement.getAttribute("id"); 228 if (ObjectHelper.isNotNullAndNonEmpty(id)) { 229 // TODO we can zap this? 230 definition.getPropertyValues() 231 .addPropertyValue("camelContext", new RuntimeBeanReference(contextId)); 232 // definition.getPropertyValues().addPropertyValue("context", 233 // builder.getBeanDefinition()); 234 parserContext.registerComponent(new BeanComponentDefinition(definition, id)); 235 } 236 } else { 237 BeanDefinitionParser parser = parserMap.get(localName); 238 if (parser != null) { 239 BeanDefinition definition = parser.parse(childElement, parserContext); 240 String id = childElement.getAttribute("id"); 241 if (ObjectHelper.isNotNullAndNonEmpty(id)) { 242 parserContext.registerComponent(new BeanComponentDefinition(definition, id)); 243 if (localName.equals("jmxAgent")) { 244 builder.addPropertyReference("camelJMXAgent", id); 245 } 246 } 247 } 248 249 } 250 } 251 } 252 // lets inject the namespaces into any namespace aware POJOs 253 injectNamespaces(element); 254 if (!createdBeanPostProcessor) { 255 // no bean processor element so lets create it by ourself 256 Element childElement = element.getOwnerDocument().createElement("beanPostProcessor"); 257 element.appendChild(childElement); 258 createBeanPostProcessor(parserContext, contextId, childElement, builder); 259 } 260 } 261 } 262 263 protected void injectNamespaces(Element element) { 264 NodeList list = element.getChildNodes(); 265 Namespaces namespaces = null; 266 int size = list.getLength(); 267 for (int i = 0; i < size; i++) { 268 Node child = list.item(i); 269 if (child instanceof Element) { 270 Element childElement = (Element)child; 271 Object object = binder.getJAXBNode(child); 272 if (object instanceof NamespaceAware) { 273 NamespaceAware namespaceAware = (NamespaceAware)object; 274 if (namespaces == null) { 275 namespaces = new Namespaces(element); 276 } 277 namespaces.configure(namespaceAware); 278 } 279 injectNamespaces(childElement); 280 } 281 } 282 } 283 }