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.model.config.PropertiesType; 035 import org.apache.camel.model.dataformat.ArtixDSDataFormat; 036 import org.apache.camel.model.dataformat.JaxbDataFormat; 037 import org.apache.camel.model.dataformat.SerializationDataFormat; 038 import org.apache.camel.model.dataformat.XMLBeansDataFormat; 039 import org.apache.camel.model.loadbalancer.RandomLoadBalanceStrategy; 040 import org.apache.camel.model.loadbalancer.RoundRobinLoadBalanceStrategy; 041 import org.apache.camel.model.loadbalancer.StickyLoadBalanceStrategy; 042 import org.apache.camel.model.loadbalancer.TopicLoadBalanceStrategy; 043 import org.apache.camel.spi.NamespaceAware; 044 import org.apache.camel.spring.CamelBeanPostProcessor; 045 import org.apache.camel.spring.CamelContextFactoryBean; 046 import org.apache.camel.spring.CamelJMXAgentType; 047 import org.apache.camel.spring.CamelTemplateFactoryBean; 048 import org.apache.camel.spring.EndpointFactoryBean; 049 import org.apache.camel.spring.remoting.CamelProxyFactoryBean; 050 import org.apache.camel.spring.remoting.CamelServiceExporter; 051 import org.apache.camel.util.ObjectHelper; 052 import org.apache.camel.view.ModelFileGenerator; 053 import org.springframework.beans.factory.BeanDefinitionStoreException; 054 import org.springframework.beans.factory.config.BeanDefinition; 055 import org.springframework.beans.factory.config.RuntimeBeanReference; 056 import org.springframework.beans.factory.parsing.BeanComponentDefinition; 057 import org.springframework.beans.factory.support.BeanDefinitionBuilder; 058 import org.springframework.beans.factory.xml.NamespaceHandlerSupport; 059 import org.springframework.beans.factory.xml.ParserContext; 060 061 062 063 /** 064 * Camel namespace for the spring XML configuration file. 065 */ 066 public class CamelNamespaceHandler extends NamespaceHandlerSupport { 067 068 protected BeanDefinitionParser endpointParser = new BeanDefinitionParser(EndpointFactoryBean.class); 069 protected BeanDefinitionParser beanPostProcessorParser = new BeanDefinitionParser(CamelBeanPostProcessor.class); 070 protected Set<String> parserElementNames = new HashSet<String>(); 071 protected Binder<Node> binder; 072 private JAXBContext jaxbContext; 073 private Map<String, BeanDefinitionParser> parserMap = new HashMap<String, BeanDefinitionParser>(); 074 075 076 public ModelFileGenerator createModelFileGenerator() throws JAXBException { 077 return new ModelFileGenerator(getJaxbContext()); 078 } 079 080 081 public void init() { 082 // remoting 083 addBeanDefinitionParser("proxy", CamelProxyFactoryBean.class); 084 addBeanDefinitionParser("template", CamelTemplateFactoryBean.class); 085 addBeanDefinitionParser("export", CamelServiceExporter.class); 086 087 // jmx agent 088 addBeanDefinitionParser("jmxAgent", CamelJMXAgentType.class); 089 090 // TODO switch to use the above mechanism? 091 registerParser("endpoint", endpointParser); 092 093 Class cl = CamelContextFactoryBean.class; 094 try { 095 cl = Class.forName("org.apache.camel.osgi.CamelContextFactoryBean"); 096 } catch (Throwable t) { 097 } 098 registerParser("camelContext", new CamelContextBeanDefinitionParser(cl)); 099 } 100 101 private void addBeanDefinitionParser(String elementName, Class<?> type) { 102 BeanDefinitionParser parser = new BeanDefinitionParser(type); 103 registerParser(elementName, parser); 104 parserMap.put(elementName, parser); 105 } 106 107 protected void createBeanPostProcessor(ParserContext parserContext, String contextId, Element childElement, BeanDefinitionBuilder parentBuilder) { 108 String beanPostProcessorId = contextId + ":beanPostProcessor"; 109 childElement.setAttribute("id", beanPostProcessorId); 110 BeanDefinition definition = beanPostProcessorParser.parse(childElement, parserContext); 111 // only register to camel context id as a String. Then we can look it up later 112 // otherwise we get a circular reference in spring and it will not allow custom bean post processing 113 // see more at CAMEL-1663 114 definition.getPropertyValues().addPropertyValue("camelId", 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 public 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(ExchangePattern.class); 168 classes.add(org.apache.camel.model.RouteType.class); 169 classes.add(org.apache.camel.model.config.StreamResequencerConfig.class); 170 classes.add(org.apache.camel.model.dataformat.DataFormatType.class); 171 classes.add(org.apache.camel.model.language.ExpressionType.class); 172 classes.add(org.apache.camel.model.loadbalancer.LoadBalancerType.class); 173 return classes; 174 } 175 176 protected class CamelContextBeanDefinitionParser extends BeanDefinitionParser { 177 public CamelContextBeanDefinitionParser(Class type) { 178 super(type); 179 } 180 181 @Override 182 protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) { 183 super.doParse(element, parserContext, builder); 184 185 String contextId = element.getAttribute("id"); 186 187 // lets avoid folks having to explicitly give an ID to a camel 188 // context 189 if (ObjectHelper.isNullOrBlank(contextId)) { 190 contextId = "camelContext"; 191 element.setAttribute("id", contextId); 192 } 193 194 // now lets parse the routes with JAXB 195 Object value = parseUsingJaxb(element, parserContext); 196 197 if (value instanceof CamelContextFactoryBean) { 198 // set the property value with the JAXB parsed value 199 CamelContextFactoryBean factoryBean = (CamelContextFactoryBean)value; 200 builder.addPropertyValue("id", contextId); 201 builder.addPropertyValue("routes", factoryBean.getRoutes()); 202 builder.addPropertyValue("intercepts", factoryBean.getIntercepts()); 203 builder.addPropertyValue("dataFormats", factoryBean.getDataFormats()); 204 builder.addPropertyValue("builderRefs", factoryBean.getBuilderRefs()); 205 builder.addPropertyValue("properties", factoryBean.getProperties()); 206 if (factoryBean.getPackages().length > 0) { 207 builder.addPropertyValue("packages", factoryBean.getPackages()); 208 } 209 } 210 211 boolean createdBeanPostProcessor = false; 212 NodeList list = element.getChildNodes(); 213 int size = list.getLength(); 214 for (int i = 0; i < size; i++) { 215 Node child = list.item(i); 216 if (child instanceof Element) { 217 Element childElement = (Element)child; 218 String localName = child.getLocalName(); 219 if (localName.equals("beanPostProcessor")) { 220 createBeanPostProcessor(parserContext, contextId, childElement, builder); 221 createdBeanPostProcessor = true; 222 } else if (localName.equals("endpoint")) { 223 BeanDefinition definition = endpointParser.parse(childElement, parserContext); 224 String id = childElement.getAttribute("id"); 225 if (ObjectHelper.isNotNullAndNonEmpty(id)) { 226 // TODO we can zap this? 227 definition.getPropertyValues() 228 .addPropertyValue("camelContext", new RuntimeBeanReference(contextId)); 229 // definition.getPropertyValues().addPropertyValue("context", 230 // builder.getBeanDefinition()); 231 parserContext.registerComponent(new BeanComponentDefinition(definition, id)); 232 } 233 } else { 234 BeanDefinitionParser parser = parserMap.get(localName); 235 if (parser != null) { 236 BeanDefinition definition = parser.parse(childElement, parserContext); 237 String id = childElement.getAttribute("id"); 238 if (ObjectHelper.isNotNullAndNonEmpty(id)) { 239 parserContext.registerComponent(new BeanComponentDefinition(definition, id)); 240 if (localName.equals("jmxAgent")) { 241 builder.addPropertyReference("camelJMXAgent", id); 242 } 243 } 244 } 245 246 } 247 } 248 } 249 // lets inject the namespaces into any namespace aware POJOs 250 injectNamespaces(element); 251 if (!createdBeanPostProcessor) { 252 // no bean processor element so lets create it by ourself 253 Element childElement = element.getOwnerDocument().createElement("beanPostProcessor"); 254 element.appendChild(childElement); 255 createBeanPostProcessor(parserContext, contextId, childElement, builder); 256 } 257 } 258 } 259 260 protected void injectNamespaces(Element element) { 261 NodeList list = element.getChildNodes(); 262 Namespaces namespaces = null; 263 int size = list.getLength(); 264 for (int i = 0; i < size; i++) { 265 Node child = list.item(i); 266 if (child instanceof Element) { 267 Element childElement = (Element)child; 268 Object object = binder.getJAXBNode(child); 269 if (object instanceof NamespaceAware) { 270 NamespaceAware namespaceAware = (NamespaceAware)object; 271 if (namespaces == null) { 272 namespaces = new Namespaces(element); 273 } 274 namespaces.configure(namespaceAware); 275 } 276 injectNamespaces(childElement); 277 } 278 } 279 } 280 }