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.builder.xml.Namespaces; 033 import org.apache.camel.model.dataformat.ArtixDSDataFormat; 034 import org.apache.camel.model.dataformat.JaxbDataFormat; 035 import org.apache.camel.model.dataformat.SerializationDataFormat; 036 import org.apache.camel.model.dataformat.XMLBeansDataFormat; 037 import org.apache.camel.model.loadbalancer.RandomLoadBalanceStrategy; 038 import org.apache.camel.model.loadbalancer.RoundRobinLoadBalanceStrategy; 039 import org.apache.camel.model.loadbalancer.StickyLoadBalanceStrategy; 040 import org.apache.camel.model.loadbalancer.TopicLoadBalanceStrategy; 041 import org.apache.camel.spi.NamespaceAware; 042 import org.apache.camel.spring.CamelBeanPostProcessor; 043 import org.apache.camel.spring.CamelContextFactoryBean; 044 import org.apache.camel.spring.CamelJMXAgentType; 045 import org.apache.camel.spring.CamelTemplateFactoryBean; 046 import org.apache.camel.spring.EndpointFactoryBean; 047 import org.apache.camel.spring.remoting.CamelProxyFactoryBean; 048 import org.apache.camel.spring.remoting.CamelServiceExporter; 049 import org.apache.camel.util.ObjectHelper; 050 import org.springframework.beans.factory.BeanDefinitionStoreException; 051 import org.springframework.beans.factory.config.BeanDefinition; 052 import org.springframework.beans.factory.config.RuntimeBeanReference; 053 import org.springframework.beans.factory.parsing.BeanComponentDefinition; 054 import org.springframework.beans.factory.support.BeanDefinitionBuilder; 055 import org.springframework.beans.factory.xml.NamespaceHandlerSupport; 056 import org.springframework.beans.factory.xml.ParserContext; 057 058 059 /** 060 * Camel namespace for the spring XML configuration file. 061 */ 062 public class CamelNamespaceHandler extends NamespaceHandlerSupport { 063 064 protected BeanDefinitionParser endpointParser = new BeanDefinitionParser(EndpointFactoryBean.class); 065 protected BeanDefinitionParser beanPostProcessorParser = new BeanDefinitionParser(CamelBeanPostProcessor.class); 066 protected Set<String> parserElementNames = new HashSet<String>(); 067 protected Binder<Node> binder; 068 private JAXBContext jaxbContext; 069 private Map<String, BeanDefinitionParser> parserMap = new HashMap<String, BeanDefinitionParser>(); 070 071 072 public void init() { 073 // remoting 074 addBeanDefinitionParser("proxy", CamelProxyFactoryBean.class); 075 addBeanDefinitionParser("template", CamelTemplateFactoryBean.class); 076 addBeanDefinitionParser("export", CamelServiceExporter.class); 077 078 // data types 079 addBeanDefinitionParser("artixDS", ArtixDSDataFormat.class); 080 addBeanDefinitionParser("jaxb", JaxbDataFormat.class); 081 addBeanDefinitionParser("serialization", SerializationDataFormat.class); 082 addBeanDefinitionParser("xmlBeans", XMLBeansDataFormat.class); 083 084 // load balancers 085 addBeanDefinitionParser("roundRobin", RoundRobinLoadBalanceStrategy.class); 086 addBeanDefinitionParser("random", RandomLoadBalanceStrategy.class); 087 addBeanDefinitionParser("sticky", StickyLoadBalanceStrategy.class); 088 addBeanDefinitionParser("topic", TopicLoadBalanceStrategy.class); 089 090 // jmx agent 091 addBeanDefinitionParser("jmxAgent", CamelJMXAgentType.class); 092 093 // TODO switch to use the above mechanism? 094 registerParser("endpoint", endpointParser); 095 096 Class cl = CamelContextFactoryBean.class; 097 try { 098 cl = Class.forName("org.apache.camel.osgi.CamelContextFactoryBean"); 099 } catch (Throwable t) { 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 definition.getPropertyValues().addPropertyValue("camelContext", new RuntimeBeanReference(contextId)); 115 parentBuilder.addPropertyReference("beanPostProcessor", beanPostProcessorId); 116 } 117 118 protected void registerScriptParser(String elementName, String engineName) { 119 registerParser(elementName, new ScriptDefinitionParser(engineName)); 120 } 121 122 protected void registerParser(String name, 123 org.springframework.beans.factory.xml.BeanDefinitionParser parser) { 124 parserElementNames.add(name); 125 registerBeanDefinitionParser(name, parser); 126 } 127 128 public Set<String> getParserElementNames() { 129 return parserElementNames; 130 } 131 132 protected Object parseUsingJaxb(Element element, ParserContext parserContext) { 133 try { 134 binder = getJaxbContext().createBinder(); 135 return binder.unmarshal(element); 136 /* 137 * Unmarshaller unmarshaller = 138 * getJaxbContext().createUnmarshaller(); return 139 * unmarshaller.unmarshal(element); 140 */ 141 } catch (JAXBException e) { 142 throw new BeanDefinitionStoreException("Failed to parse JAXB element: " + e, e); 143 } 144 } 145 146 protected JAXBContext getJaxbContext() throws JAXBException { 147 if (jaxbContext == null) { 148 jaxbContext = createJaxbContext(); 149 } 150 return jaxbContext; 151 } 152 153 protected JAXBContext createJaxbContext() throws JAXBException { 154 StringBuilder packages = new StringBuilder(); 155 for (Class cl : getJaxbPackages()) { 156 if (packages.length() > 0) { 157 packages.append(":"); 158 } 159 packages.append(cl.getName().substring(0, cl.getName().lastIndexOf('.'))); 160 } 161 return JAXBContext.newInstance(packages.toString(), getClass().getClassLoader()); 162 } 163 164 protected Set<Class> getJaxbPackages() { 165 Set<Class> classes = new HashSet<Class>(); 166 classes.add(org.apache.camel.spring.CamelContextFactoryBean.class); 167 classes.add(org.apache.camel.model.RouteType.class); 168 classes.add(org.apache.camel.model.config.StreamResequencerConfig.class); 169 classes.add(org.apache.camel.model.dataformat.DataFormatType.class); 170 classes.add(org.apache.camel.model.language.ExpressionType.class); 171 classes.add(org.apache.camel.model.loadbalancer.LoadBalancerType.class); 172 return classes; 173 } 174 175 protected class CamelContextBeanDefinitionParser extends BeanDefinitionParser { 176 public CamelContextBeanDefinitionParser(Class type) { 177 super(type); 178 } 179 180 @Override 181 protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) { 182 super.doParse(element, parserContext, builder); 183 184 String contextId = element.getAttribute("id"); 185 186 // lets avoid folks having to explicitly give an ID to a camel 187 // context 188 if (ObjectHelper.isNullOrBlank(contextId)) { 189 contextId = "camelContext"; 190 element.setAttribute("id", contextId); 191 } 192 193 // now lets parse the routes 194 Object value = parseUsingJaxb(element, parserContext); 195 if (value instanceof CamelContextFactoryBean) { 196 CamelContextFactoryBean factoryBean = (CamelContextFactoryBean)value; 197 builder.addPropertyValue("id", contextId); 198 builder.addPropertyValue("routes", factoryBean.getRoutes()); 199 builder.addPropertyValue("intercepts", factoryBean.getIntercepts()); 200 builder.addPropertyValue("builderRefs", factoryBean.getBuilderRefs()); 201 202 if (factoryBean.getPackages().length > 0) { 203 builder.addPropertyValue("packages", factoryBean.getPackages()); 204 } 205 } 206 207 boolean createdBeanPostProcessor = false; 208 NodeList list = element.getChildNodes(); 209 int size = list.getLength(); 210 for (int i = 0; i < size; i++) { 211 Node child = list.item(i); 212 if (child instanceof Element) { 213 Element childElement = (Element)child; 214 String localName = child.getLocalName(); 215 if (localName.equals("beanPostProcessor")) { 216 createBeanPostProcessor(parserContext, contextId, childElement, builder); 217 createdBeanPostProcessor = true; 218 } else if (localName.equals("endpoint")) { 219 BeanDefinition definition = endpointParser.parse(childElement, parserContext); 220 String id = childElement.getAttribute("id"); 221 if (ObjectHelper.isNotNullAndNonEmpty(id)) { 222 // TODO we can zap this? 223 definition.getPropertyValues() 224 .addPropertyValue("camelContext", new RuntimeBeanReference(contextId)); 225 // definition.getPropertyValues().addPropertyValue("context", 226 // builder.getBeanDefinition()); 227 parserContext.registerComponent(new BeanComponentDefinition(definition, id)); 228 } 229 } else { 230 BeanDefinitionParser parser = parserMap.get(localName); 231 if (parser != null) { 232 BeanDefinition definition = parser.parse(childElement, parserContext); 233 String id = childElement.getAttribute("id"); 234 if (ObjectHelper.isNotNullAndNonEmpty(id)) { 235 parserContext.registerComponent(new BeanComponentDefinition(definition, id)); 236 if (localName.equals("jmxAgent")) { 237 builder.addPropertyReference("camelJMXAgent", id); 238 } 239 } 240 } 241 242 } 243 } 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 }