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 import org.w3c.dom.Element; 028 import org.w3c.dom.Node; 029 import org.w3c.dom.NodeList; 030 031 import org.apache.camel.ExchangePattern; 032 import org.apache.camel.builder.xml.Namespaces; 033 import org.apache.camel.model.FromDefinition; 034 import org.apache.camel.model.SendDefinition; 035 import org.apache.camel.model.config.PropertiesDefinition; 036 import org.apache.camel.model.dataformat.ArtixDSDataFormat; 037 import org.apache.camel.model.dataformat.JaxbDataFormat; 038 import org.apache.camel.model.dataformat.SerializationDataFormat; 039 import org.apache.camel.model.dataformat.XMLBeansDataFormat; 040 import org.apache.camel.model.loadbalancer.RandomLoadBalanceStrategy; 041 import org.apache.camel.model.loadbalancer.RoundRobinLoadBalanceStrategy; 042 import org.apache.camel.model.loadbalancer.StickyLoadBalanceStrategy; 043 import org.apache.camel.model.loadbalancer.TopicLoadBalanceStrategy; 044 import org.apache.camel.spi.NamespaceAware; 045 import org.apache.camel.spring.CamelBeanPostProcessor; 046 import org.apache.camel.spring.CamelContextFactoryBean; 047 import org.apache.camel.spring.CamelJMXAgentDefinition; 048 import org.apache.camel.spring.CamelTemplateFactoryBean; 049 import org.apache.camel.spring.EndpointFactoryBean; 050 import org.apache.camel.spring.remoting.CamelProxyFactoryBean; 051 import org.apache.camel.spring.remoting.CamelServiceExporter; 052 import org.apache.camel.util.ObjectHelper; 053 import org.apache.camel.view.ModelFileGenerator; 054 import org.springframework.beans.factory.BeanDefinitionStoreException; 055 import org.springframework.beans.factory.config.BeanDefinition; 056 import org.springframework.beans.factory.config.RuntimeBeanReference; 057 import org.springframework.beans.factory.parsing.BeanComponentDefinition; 058 import org.springframework.beans.factory.support.BeanDefinitionBuilder; 059 import org.springframework.beans.factory.xml.NamespaceHandlerSupport; 060 import org.springframework.beans.factory.xml.ParserContext; 061 062 /** 063 * Camel namespace for the spring XML configuration file. 064 */ 065 public class CamelNamespaceHandler extends NamespaceHandlerSupport { 066 067 protected BeanDefinitionParser endpointParser = new BeanDefinitionParser(EndpointFactoryBean.class); 068 protected BeanDefinitionParser beanPostProcessorParser = new BeanDefinitionParser(CamelBeanPostProcessor.class); 069 protected Set<String> parserElementNames = new HashSet<String>(); 070 protected Binder<Node> binder; 071 private JAXBContext jaxbContext; 072 private Map<String, BeanDefinitionParser> parserMap = new HashMap<String, BeanDefinitionParser>(); 073 074 public ModelFileGenerator createModelFileGenerator() throws JAXBException { 075 return new ModelFileGenerator(getJaxbContext()); 076 } 077 078 public void init() { 079 // remoting 080 addBeanDefinitionParser("proxy", CamelProxyFactoryBean.class); 081 addBeanDefinitionParser("template", CamelTemplateFactoryBean.class); 082 addBeanDefinitionParser("export", CamelServiceExporter.class); 083 084 // data types 085 addBeanDefinitionParser("artixDS", ArtixDSDataFormat.class); 086 addBeanDefinitionParser("jaxb", JaxbDataFormat.class); 087 addBeanDefinitionParser("serialization", SerializationDataFormat.class); 088 addBeanDefinitionParser("xmlBeans", XMLBeansDataFormat.class); 089 090 // load balancers 091 addBeanDefinitionParser("roundRobin", RoundRobinLoadBalanceStrategy.class); 092 addBeanDefinitionParser("random", RandomLoadBalanceStrategy.class); 093 addBeanDefinitionParser("sticky", StickyLoadBalanceStrategy.class); 094 addBeanDefinitionParser("topic", TopicLoadBalanceStrategy.class); 095 096 // jmx agent 097 addBeanDefinitionParser("jmxAgent", CamelJMXAgentDefinition.class); 098 099 // endpoint 100 addBeanDefinitionParser("endpoint", EndpointFactoryBean.class); 101 102 // camel context 103 Class cl = CamelContextFactoryBean.class; 104 try { 105 cl = Class.forName("org.apache.camel.osgi.CamelContextFactoryBean"); 106 } catch (Throwable t) { 107 // not running with camel-osgi so we fallback to the regular factory bean 108 } 109 registerParser("camelContext", new CamelContextBeanDefinitionParser(cl)); 110 } 111 112 private void addBeanDefinitionParser(String elementName, Class<?> type) { 113 BeanDefinitionParser parser = new BeanDefinitionParser(type); 114 registerParser(elementName, parser); 115 parserMap.put(elementName, parser); 116 } 117 118 protected void createBeanPostProcessor(ParserContext parserContext, String contextId, Element childElement, BeanDefinitionBuilder parentBuilder) { 119 String beanPostProcessorId = contextId + ":beanPostProcessor"; 120 childElement.setAttribute("id", beanPostProcessorId); 121 BeanDefinition definition = beanPostProcessorParser.parse(childElement, parserContext); 122 definition.getPropertyValues().addPropertyValue("camelContext", new RuntimeBeanReference(contextId)); 123 parentBuilder.addPropertyReference("beanPostProcessor", beanPostProcessorId); 124 } 125 126 protected void registerScriptParser(String elementName, String engineName) { 127 registerParser(elementName, new ScriptDefinitionParser(engineName)); 128 } 129 130 protected void registerParser(String name, org.springframework.beans.factory.xml.BeanDefinitionParser parser) { 131 parserElementNames.add(name); 132 registerBeanDefinitionParser(name, parser); 133 } 134 135 public Set<String> getParserElementNames() { 136 return parserElementNames; 137 } 138 139 protected Object parseUsingJaxb(Element element, ParserContext parserContext) { 140 try { 141 binder = getJaxbContext().createBinder(); 142 return binder.unmarshal(element); 143 } catch (JAXBException e) { 144 throw new BeanDefinitionStoreException("Failed to parse JAXB element: " + e, e); 145 } 146 } 147 148 public JAXBContext getJaxbContext() throws JAXBException { 149 if (jaxbContext == null) { 150 jaxbContext = createJaxbContext(); 151 } 152 return jaxbContext; 153 } 154 155 protected JAXBContext createJaxbContext() throws JAXBException { 156 StringBuilder packages = new StringBuilder(); 157 for (Class cl : getJaxbPackages()) { 158 if (packages.length() > 0) { 159 packages.append(":"); 160 } 161 packages.append(cl.getName().substring(0, cl.getName().lastIndexOf('.'))); 162 } 163 return JAXBContext.newInstance(packages.toString(), getClass().getClassLoader()); 164 } 165 166 protected Set<Class> getJaxbPackages() { 167 Set<Class> classes = new HashSet<Class>(); 168 classes.add(org.apache.camel.spring.CamelContextFactoryBean.class); 169 classes.add(ExchangePattern.class); 170 classes.add(org.apache.camel.model.RouteDefinition.class); 171 classes.add(org.apache.camel.model.config.StreamResequencerConfig.class); 172 classes.add(org.apache.camel.model.dataformat.DataFormatDefinition.class); 173 classes.add(org.apache.camel.model.language.ExpressionDefinition.class); 174 classes.add(org.apache.camel.model.loadbalancer.LoadBalancerDefinition.class); 175 return classes; 176 } 177 178 protected class CamelContextBeanDefinitionParser extends BeanDefinitionParser { 179 public CamelContextBeanDefinitionParser(Class type) { 180 super(type); 181 } 182 183 @Override 184 protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) { 185 super.doParse(element, parserContext, builder); 186 187 String contextId = element.getAttribute("id"); 188 189 // lets avoid folks having to explicitly give an ID to a camel context 190 if (ObjectHelper.isEmpty(contextId)) { 191 contextId = "camelContext"; 192 element.setAttribute("id", contextId); 193 } 194 195 // now lets parse the routes 196 Object value = parseUsingJaxb(element, parserContext); 197 if (value instanceof CamelContextFactoryBean) { 198 CamelContextFactoryBean factoryBean = (CamelContextFactoryBean)value; 199 builder.addPropertyValue("id", contextId); 200 builder.addPropertyValue("routes", factoryBean.getRoutes()); 201 builder.addPropertyValue("intercepts", factoryBean.getIntercepts()); 202 builder.addPropertyValue("dataFormats", factoryBean.getDataFormats()); 203 builder.addPropertyValue("exceptionClauses", factoryBean.getExceptionClauses()); 204 builder.addPropertyValue("builderRefs", factoryBean.getBuilderRefs()); 205 builder.addPropertyValue("properties", factoryBean.getProperties()); 206 207 if (factoryBean.getPackages().length > 0) { 208 builder.addPropertyValue("packages", factoryBean.getPackages()); 209 } 210 } 211 212 boolean createdBeanPostProcessor = false; 213 NodeList list = element.getChildNodes(); 214 int size = list.getLength(); 215 for (int i = 0; i < size; i++) { 216 Node child = list.item(i); 217 if (child instanceof Element) { 218 Element childElement = (Element)child; 219 String localName = child.getLocalName(); 220 if (localName.equals("beanPostProcessor")) { 221 createBeanPostProcessor(parserContext, contextId, childElement, builder); 222 createdBeanPostProcessor = true; 223 } else if (localName.equals("endpoint")) { 224 registerEndpoint(childElement, parserContext, contextId); 225 } else { 226 BeanDefinitionParser parser = parserMap.get(localName); 227 if (parser != null) { 228 BeanDefinition definition = parser.parse(childElement, parserContext); 229 String id = childElement.getAttribute("id"); 230 if (ObjectHelper.isNotEmpty(id)) { 231 parserContext.registerComponent(new BeanComponentDefinition(definition, id)); 232 if (localName.equals("jmxAgent")) { 233 builder.addPropertyReference("camelJMXAgent", id); 234 } 235 } 236 } 237 238 } 239 } 240 } 241 242 // register as endpoint defined indirectly in the routes by from/to types having id explict set 243 registerEndpointsWithIdsDefinedInFromToTypes(element, parserContext, contextId); 244 245 // lets inject the namespaces into any namespace aware POJOs 246 injectNamespaces(element); 247 if (!createdBeanPostProcessor) { 248 // no bean processor element so lets create it by ourself 249 Element childElement = element.getOwnerDocument().createElement("beanPostProcessor"); 250 element.appendChild(childElement); 251 createBeanPostProcessor(parserContext, contextId, childElement, builder); 252 } 253 } 254 } 255 256 protected void injectNamespaces(Element element) { 257 NodeList list = element.getChildNodes(); 258 Namespaces namespaces = null; 259 int size = list.getLength(); 260 for (int i = 0; i < size; i++) { 261 Node child = list.item(i); 262 if (child instanceof Element) { 263 Element childElement = (Element)child; 264 Object object = binder.getJAXBNode(child); 265 if (object instanceof NamespaceAware) { 266 NamespaceAware namespaceAware = (NamespaceAware)object; 267 if (namespaces == null) { 268 namespaces = new Namespaces(element); 269 } 270 namespaces.configure(namespaceAware); 271 } 272 injectNamespaces(childElement); 273 } 274 } 275 } 276 277 protected void registerEndpointsWithIdsDefinedInFromToTypes(Element element, ParserContext parserContext, String contextId) { 278 NodeList list = element.getChildNodes(); 279 int size = list.getLength(); 280 for (int i = 0; i < size; i++) { 281 Node child = list.item(i); 282 if (child instanceof Element) { 283 Element childElement = (Element)child; 284 Object object = binder.getJAXBNode(child); 285 // we only want from/to types to be registered as endpoints 286 if (object instanceof FromDefinition || object instanceof SendDefinition) { 287 registerEndpoint(childElement, parserContext, contextId); 288 } 289 // recursive 290 registerEndpointsWithIdsDefinedInFromToTypes(childElement, parserContext, contextId); 291 } 292 } 293 } 294 295 private void registerEndpoint(Element childElement, ParserContext parserContext, String contextId) { 296 String id = childElement.getAttribute("id"); 297 // must have an id to be registered 298 if (ObjectHelper.isNotEmpty(id)) { 299 BeanDefinition definition = endpointParser.parse(childElement, parserContext); 300 definition.getPropertyValues().addPropertyValue("camelContext", new RuntimeBeanReference(contextId)); 301 parserContext.registerComponent(new BeanComponentDefinition(definition, id)); 302 } 303 } 304 305 }